scala中的函数 break 匿名函数

package nj

import java.lang

/**
  * @author WGY
  * 函数
  */
object FunctionDemo2 {
  def main(args: Array[String]): Unit = {
    //函数定义
    def fun(a: Int, b: Int): Int = if (a > b) a else b

    println("fun:" + fun(4, 2))

    //递归函数
    def fun1(a: Int): Int = {
      if (a == 1) 1
      else a + fun1(a - 1)
    }

    val result: Int = fun1(3)
    println("fun1:" + result)


    //break的使用
    def fun2(a: Int) = {
      import scala.util.control.Breaks
      val loop = new Breaks
      loop.breakable(
        for (i <- 1 to a) {
          if (i == 4) loop.break()
          println(i)
        }
      )

      //第二种方式
      Breaks.breakable(
        for (i <- 1 to a) {
          if (i == 4) Breaks.break()
          println(i)
        }
      )
    }

    fun2(8)


    //参数的默认值
    def fun3(a: Int = 10, b: Int = 20): Int = {
      a + b
    }

    println("fun3:" + fun3())
    println("fun3:" + fun3(a = 100))
    println("fun3:" + fun3(b = 100))
    println("fun3:" + fun3(a = 100, b = 100))


    //参数长度可变
    def fun4(s: String*) = {
      println("fun4:" + s)
      println("长度是：" + s.length)
      s.foreach(println) //第一种遍历方法
      for (i <- s) { //第二种遍历方法
        println(i)
      }
    }

    fun4("a", "b", "c")


    //匿名函数  下两者相同
    def fun5 = (a: Int, b: Int) => {
      a + b
    }

    def fun6: (Int, Int) => Int = (a: Int, b: Int) => {
      a + b
    }

    println("fun5:" + fun5(2, 3))
    println("fun6:" + fun6(3, 4))

    def fun7 = (a: Int, b: Int, c: Int) => {
      a + b + c
    }

    println(fun7(1, 2, 3))


    //高阶函数
    //1、使用函数作为参数
    //普通函数
    def fun8(a: Int, b: Int): Int = {
      a + b
    }

    //使用函数作为参数
    def fun9(f: (Int, Int) => Int) = {
      val a = 100
      val b = 50
      val result: Int = f(a, b)
      println("fun:" + result)
    }

    fun9(fun8)

    def fun10(a: Int, b: Int): Int = {
      a - b
    }

    fun9(fun10)


    def fun11(a: String, b: String): String = {
      a + b
    }

    def fun12(f: (String, String) => String) = {
      val a = "hello "
      val b = "world!"
      val c = f(a, b)
      println("fun12:" + c)
    }

    fun12(fun11)

    //函数作为返回值
    def fun13(s: String): (Int, Int) => Int = {
      if (s.length > 5) {
        def fun1(a: Int, b: Int): Int = {
          a + b
        }

        fun1
      } else {
        def fun2(a: Int, b: Int): Int = {
          a - b
        }

        fun2
      }
    }

    val result1 = fun13("hello")(4, 2)
    println("fun13:" + result1)


    //函数作为参数，函数作为返回值
    //a%2==0 返回一个加法的函数
    //a%2!=0 返回一个减法
    def fun14_1(a: Int): Int = {
      a % 2
    }

    def fun14(a: Int, f: (Int) => Int): (Int, Int) => Int = {
      val i = fun14_1(a)
      if (i == 0) {
        def funJia(a: Int, b: Int): Int = {
          a + b
        }

        funJia
      } else {
        def funJian(a: Int, b: Int): Int = {
          a - b
        }

        funJian
      }
    }

    println("fun14:" + fun14(4, fun14_1)(4, 2))
    println("fun14:" + fun14(3, fun14_1)(4, 2))


    //函数的克里化
    def fun15(a: Int, b: Int, c: Int, d: Int): Int = {
      a + b + c + d
    }

    val sum15 = fun15(1, 2, 3, 4)
    println("fun15:" + sum15)

    def fun15_1(a: Int, b: Int)(c: Int, d: Int): Int = {
      a + b + c + d
    }

    def fun15_2(a: Int)(b: Int)(c: Int)(d: Int): Int = {
      a + b + c + d
    }

    var sum15_1 = fun15_1(1, 2)(3, 4)
    var sum15_2 = fun15_2(1)(2)(3)(4)
    println("fun15_1:" + sum15_1, "fun15_2:" + sum15_2)

    //隐式参数
    implicit var tmp1: Int = 5

    def fun15_3(a: Int)(b: Int)(c: Int)(d: Int)(implicit e: Int): Int = {
      a + b + c + d
    }

    val i1 = fun15_3(1)(2)(3)(4)
    val i2 = fun15_3(1)(2)(3)(4)(5)
    val i3 = fun15_3(1)(2)(3)(4)(100)
    println("fun15_3:i1:  " + i1, "  fun15_3:i2:  " + i2, "  fun15_3:i3:  " + i3)
    //多个隐式函数
    implicit var tmp2: String = "fuck"

    def fun15_4(a: Int)(b: Int)(c: Int)(d: Int)(implicit e: Int, f: String): Int = {
      println(f)
      a + b + c + d
    }

    println("fun15_4:" + fun15_4(1)(2)(3)(4))


    //部分函数 偏函数
    def fun16(title: String, content: String) = {
      println(title + "  " + content)
    }

    def fun16_1(title: String, content: String, height: Double) = {
      println(title + "  " + content + ":" + height + "m")
    }

    fun16("警告", "水位超过警戒线!")
    val title: String = "警告"

    def fun17 = fun16(title, _: String)

    fun17("水位超过警戒线1米")

    def fun17_1 = fun16_1(title, _: String, _: Double)

    fun17_1("水位超过警戒线", 2.0)


    def fun18(a: Int, b: Int): Int = a + b

    def fun18_1 = fun18(_: Int, _: Int)

    println("fun18_1:"+fun18_1(1,2))

    def fun19:PartialFunction[String,Int]={
      case "hello"=>1
      case "world"=>2
      case _=>3
    }
    val i = fun19("hello")
    println("fun19:"+i)

    def fun20:PartialFunction[Any,Int]={
      case i:Int=>i
      case _=>0
    }
    println("fun20:"+fun20("s")
    )


    var list = List("a",2,3,4.5)
    val ints:List[Int] = list.collect(fun20)
    ints.foreach(println)


  }
}

输出结果：

fun:4
fun1:6
1
2
3
1
2
3
fun3:30
fun3:120
fun3:110
fun3:200
fun4:WrappedArray(a, b, c)
长度是：3
a
b
c
a
b
c
fun5:5
fun6:7
6
fun:150
fun:50
fun12:hello world!
fun13:2
fun14:6
fun14:2
fun15:10
(fun15_1:10,fun15_2:10)
(fun15_3:i1:  10,  fun15_3:i2:  10,  fun15_3:i3:  10)
fuck
fun15_4:10
警告  水位超过警戒线!
警告  水位超过警戒线1米
警告  水位超过警戒线:2.0m
fun18_1:3
fun19:1
fun20:0
0
2
3
0

Process finished with exit code 0