scala

函数式编程

1.基本语法

[修饰符] def 函数名 ( 参数列表 ) [:返回值类型] = {
    函数体
}
private def test( s : String ) : Unit = {
    println(s)
}

2.函数定义

无返回值，调用函数后不用print;有返回值，调用函数需要print

1)无参，无返回值
object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun1(): Unit = {
            println("函数体")
        }
        fun1()
    }
}
2)无参，有返回值
object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun2(): String = {
            "zhangsan"
        }
        println( fun2() )
    }
}
3）有参，无返回值
object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun3( name:String ): Unit = {
            println( name )
        }
        fun3("zhangsan")
    }
}
4）有参，有返回值
object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4(name:String): String = {
            "Hello " + name
        }
        println( fun4("zhangsan") )
    }
}
5）多参，无返回值
object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(hello:String, name:String): Unit = {
            println( hello + " " + name )
        }
        fun5("Hello", "zhangsan")
    }
}
6）多参，有返回值
object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun6(hello:String, name:String): String = {
            hello + " " + name
        }
        println( fun6("Hello", "zhangsan"))
    }
}

3.函数参数

3.1可变参数 （数据类型后面加*）

注意：可变参数不能放置在参数列表的前面，一般放置在参数列表的最后

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun7(names:String*): Unit = {
            println(names)
        }
        fun7()
        fun7( "zhangsan" )
        fun7( "zhangsan", "lisi" )
    }
}

3.2参数默认值

注意：参数默认值与可变参数不能同时使用

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun8( name:String, password:String = "000000" ): Unit = {
            println( name + "," + password )
        }
        fun8("zhangsan", "123123")
        fun8("zhangsan")
    }
}

如果使name和password交换参数的位置，就没有办法使用默认参数值，故引入带名参数

3.2带名参数

参数传递一般是顺序传递，增加参数的名称，用于改变传参的顺序

object Function02 {
  def main(args: Array[String]): Unit = {
    def fun1(name: String ="lisi",password:String): Unit ={
      println(name + password)
    }

    fun1(password = "123313")
  }

}

4.函数至简原则

能省就省

4.1省略return关键字

函数体 会将满足条件的最后一行代码的执行结果作为函数的返回值

object Function02 {
  def main(args: Array[String]): Unit = {
   def fun1(): String={
        "za"
   }

    println(fun1())
  }

}

4.2省略花括号

如果函数体中的逻辑代码只有一行，那么花括号可以省略

object Function02 {
  def main(args: Array[String]): Unit = {
   def fun1(): String= "za"
   

    println(fun1())
  }

}

4.3省略返回值类型

如果函数返回数据可以推断出返回值类型的话，返回值类型可以省略

object Function02 {
  def main(args: Array[String]): Unit = {
   def fun1()="za"
   

    println(fun1())
  }

}

4.4省略参数列表

如果参数列表中没有声明任何的参数，那么参数列表可以省略，但省略之后，调用时也不能加参数列表了

object Function02 {
  def main(args: Array[String]): Unit = {
   def fun1="za"
   

    println(fun1)
  }

}

4.5省略等号 一般返回值类型为unit时省略

如果函数体中有明确的return语句，那么返回值类型不能省略

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(): String = {
            return "zhangsan"
        }
        println(fun5())
    }
}

如果函数体返回值类型明确为Unit, 那么函数体中即使有return关键字也不起作用

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5(): Unit = {
            return "zhangsan"
        }
        println(fun5())
    }
}

如果函数体返回值类型声明为Unit, 但是又想省略，那么此时就必须连同等号一起省略

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun5() {
            return "zhangsan"
        }
        println(fun5())
    }
}

4.6省略名称和关键字

省略的同时也需要将返回值类型同时省略，将等号增加一个箭头 匿名函数不能独立使用

object Function02 {
  def main(args: Array[String]): Unit = {
  def fun1(): String ={
    "xiaobu"
  }
  }

}
object Function02 {
  def main(args: Array[String]): Unit = {
  ()=>{
      "xiaobu"
  }
  }

}

5高阶函数编程

所谓的高阶函数，其实就是将函数当成一个类型来使用，而不是当成特定的语法结构

5.1函数作为值

如果将函数作为整体，而不是将执行结果赋值给变量，那么需要采用特殊符号：下划线

之所以使用下划线让函数作为对象使用，因为代码中没有明确变量的类型，所以需要通过取值类推断

如果变量声明的类型为函数类型，那么可以不适用下划线让函数作为对象

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

    def fun1(): String ={
      "zahnsgan"
    }
   val a = fun1()
    println(a)                   //zahnsgan
    println("````````")
    def fun2(): Unit ={
      println("lisi")
    }
    val b = fun2()              //lisi
    println(b)                  // ()
    println("````````")
    def fun3(): Unit ={
      println("zhangsan")
    }
    val c = fun3 _            //将函数对象传给c
    c()                       //()调用函数
  }

}
   val c :() = > unit = fun3  这里可以省略_

5.2函数作为参数

将函数作为参数传入到函数中，记得传入参数时需去掉（）即 传入函数类型的值 fun 或者 fun(因为知道传入的类型为函数类型，所以可以省略)

不去掉（）的话会直接执行 会将执行结果作为参数传入

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

  def test(f:() => Unit): Unit ={
    f()
  }
    def fun1(): Unit ={
      println("11111")
    }
  test(fun1)
    println("****************")
    def test1(f : (Int,Int) => Int): Unit ={
      val i = f(10,20)
      println(i)
    }

    def fun2(x :Int,y: Int): Int ={
      x + y
    }
    test1(fun2)
    println("****************")
    def test2(f : (Int,Int) => Int): Int ={
      f(10,20)

    }

    def fun3(x :Int,y: Int): Int ={
      x + y
    }
    test1(fun3)
 
}
}

scala(二)

原文：https://www.cnblogs.com/xiao-bu/p/14787447.html