scala基础内容 函数式编程与基础函数，匿名函数，递归练习

函数式编程

scala是完全面向函数式编程语言
函数式编程最关心的是问题的解决方案（封装的功能），重点在于函数的功能，函数的入参和函数的出参
函数式编程完全就是依托于函数而实现的
scala中函数的关键字：def

普通的函数

有参，有返回值

//i : Int   i 入参的参数名  Int 入参的类型，整形
//:Int=     有返回值，返回值类型为Int
//return i; 返回语句，返回值为i
		def test(i : Int):Int={
		     return i;
		}
		print(test(2))

无参，无返回值

//:Unit=     无返回值，返回值类型为Unit
    def test1():Unit={
          print("test1")
    }
    test1()
//如果函数声明时，明确无返回值（Unit），那么即使函数中有return也不起作用
//输出内容为  ()
    def test3(): Unit ={
      return "aaa"
    }
    print(test3());

有参，无返回值

//输出内容为  sss+++test2
    def test2(i : String): Unit ={
      print(i+"+++test2")
    }
    test2("sss")

    def test3(): Unit ={
      return "aaa"
    }
    print(test3());

scala至简原则

1.如果将函数的最后一行代码作为返回值，那么return关键字可以省略
2.如果可以根据函数的最后一行来推断返回类型，那么返回值类型可以省略
3.如果函数体中只有一行代码，大括号可以省略
4.如果函数声明中没有参数列表，小括号可以省略，如果函数小括号省略，那么访问函数时不能增加小括号，def关键字用来区分是变量还是函数，所以def关键字不能省略
5.如果函数没有参数列表，但是没有省略小括号，调用时可加可不加
6.如果明确函数没有返回值，那么等号可以省略，省略后，编译器不会将最后一行代码作为返回值

	//如果将函数的最后一行代码作为返回值，那么return关键字可以省略
    def test4(): String ={
      "aaa"
    }
    print(test4());
    //如果可以根据函数的最后一行来推断返回类型，那么返回值类型可以省略
    def test5()={
      "aaa"
    }
    print(test5());
    //如果函数体中只有一行代码，大括号可以省略
    def test6()="aaa"
    print(test6());
	//如果函数声明中没有参数列表，小括号可以省略
	//如果函数小括号省略，那么访问函数时不能增加小括号
	//def关键字用来区分是变量还是函数，所以def关键字不能省略
    def test7 = "test";
    //常量val
    val test8 = "test2"
    println(test7)
    print(test8)
    //如果函数没有参数列表，但是没有省略小括号，调用时可加可不加
	println(test4)
	//如果明确函数没有返回值，那么等号可以省略，省略后，编译器不会将最后一行代码作为返回值
	 def test9(){
     	"test9"
    }
    println(test9)

匿名函数

//不需要外部引用，直接执行，类似于java的代码块,符号为->
()->{
	println(5555)
}
//调用执行，符号为=>
val test10: () => Unit = () => {
	println("aaa")
}
test10()

可变参数

scala中用 * 来标记可变参数，与java中的…作用一样

//用*来表示可变参数
def test11(name : String*): Unit ={
	println(name)
}
//调用函数的时候，可以传零个到多个
//输出结果为  WrappedArray(aa, bb)
test11("aa","bb")
//输出结果为  List()
test11()

默认参数

//如果希望函数中的某个参数使用默认值，那么可以在声明时直接赋值
//scala中没有重载的概念，所以可以使用默认参数来实现重载的效果
def test12(name : String,age : Int = 20): Unit ={
	println(s"${name}+${age}");
}
//输出结果为  test12+20
test12("test12")
//输出结果为  test12+50
test12("test12",50)
//尽量不要把默认参数放到首位，在调用时会出错，可以使用带名参数访问
//调用函数时，参数匹配规则为从前到后，从左到右
def test12(name : String = "aa",age : Int): Unit ={
	 println(s"${name}+${age}");
}
    //编译报错
//    test12("test12");
    //带名参数，将传输的参数与声明的参数对应
    test12(age = 52)

函数的高级使用

//TODO scala是完全面向函数式编程语言
//函数在scala中可以做任何事情
//函数可以赋值给变量，函数可以作为函数的参数，函数可以作为函数的返回值
        def fun(): Unit ={
          println("fun")
        }
        def fun0() ={
      		//返回函数
     	 	//在函数体中直接返回函数，会有问题
     		//fun
      		//需要增加特殊符号：下划线(_)
      		fun _
    	}
    	//使用双小括号来进行调用
        fun0()()
    //进行一定优化，函数中嵌套函数
    	def fun1() ={
	   		 def fun2(): Unit ={
			     println("fun2");
    	    }
    	    fun2 _
   		 }
    	 fun1()()

函数科里化

柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。

def fun3()(): Unit ={
  println("fun3++科里化")
}
fun3()()

闭包

闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

    //一个函数在实现逻辑时，将外部的变量引入到函数的内部，改变了这个变量的生命周期，称之为闭包
    def fun4(i : Int)={
      //改变i的作用域，使得i能够在fun4声明完之后，依然存在于fun5中
      def fun5(j : Int=20)={
        i * j
      }
      fun5 _
    }
    //当fun4声明完毕之后，i应该是已经出栈的，但是内部的函数fun5却又需要调用变量i
    //于是scala就有了闭包的概念，将变量i的生命周期发生变化，使得变量i能够在fun4声明完之后，依然存在于fun5中
    val intToInt = fun4(4)
    println(intToInt(10))

函数作为函数的参数

		//定义无参函数fun6，返回值为Int类型的5
        def fun6(): Int ={
          5
        }
        //用  () => 类型  来声明函数参数
        //定义函数fun7，参数为  返回类型为Int的无参函数
        def fun7(f : () => Int): Int ={
          f() + 50
        }
		//打印结果为55
        println(fun7(fun6))
        
        //使用 匿名函数 作为参数
        def fun8(f : () => Unit)={
          f()
        }
        fun8(()=>{println("匿名函数---fun8")})
		//使用 有参 匿名函数 作为参数
        def fun9(f:(Int) => Unit): Unit ={
          f(20)
        }
    	fun9((i:Int)=>{print(i)})
		//至简原则
		//因为函数中定义为Int，所以可以在调用的时候省略Int
   		fun9((i)=>{print(i)})
    	//因为只有一行，可以省略{}
  	    fun9((i)=>print(i))
   	    //当参数值用到一次的情况下，可以省略(i)=>，并用_来替换i
  	    fun9(print(_))
    	//因为只有一个参数，所以(_)可以省略
    	fun9(print)
		
		
    //两参数求和
    def fun10(f: (Int, Int) => Int): Int = {
      f(20, 20)
    }
    //定义函数来调用
    def fun11(x: Int, y: Int) = {
      x + y
    }
    println(fun10(fun11))

    //用匿名函数来调用
    println(fun10((x: Int, y: Int) => {
      x + y
    }))
    //简化
    println(fun10((x, y) => x + y))
    //只用一次，所以x和y都用_代替
    println(fun10(_ + _))

递归

递归：

1. 函数的逻辑代码中调用自身
2. 函数在调用自身时，传递的参数应该有规律
3. 函数应该有跳出的逻辑，否则出现死循环

    //递归练习
    //函数的逻辑代码中调用自身
    //函数在调用自身时，传递的参数应该有规律
    //函数应该有跳出的逻辑，否则出现死循环
    //递归函数无法推断出函数的返回值类型，所以必须要声明
    //阶乘
    //定义一个名为!!的函数，参数为Int型，返回值为Int
    def !!(i: Int): Int = {
      if (i > 1) {
        i * !!(i - 1)
      } else {
        1
      }
    }
    println(!!(5))