Scala06_函数式编程

基础函数编程

1.定义函数的基本语法

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

private def test( s : String ) : Unit = {
    println(s)
}

2.函数&方法

scala 中存在方法与函数两个不同的概念，二者在语义上的区别很小

方法

• scala 方法其实就是函数，只不过声明在类中，是类的一部分；换句话来说在类中定义的函数即是方法，在别的地方声明的函数就是普通函数。
• 方法是有重载和重写的。但是对于在同一个作用域中的函数来说，如果名称相同，就会出现错误

函数

• 函数是一个对象，可以赋值给一个变量
• 函数可以嵌套声明使用，方法就没有这个能力了，千万记得哟

关于作用域说明

• 函数仅仅在当前作用域中有效
• 方法可以脱离本类，在类的外部调用，通过对象就可以调用

3.函数定义

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

4.函数参数

1) 可变参数

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

• 可变参数使用场景：参数类型相同，但是个数不确定
• 可变参数 底层将参数列表封装成一个集合，可以不传参数，也可以传多个参数
• 可变参数不能放置在参数列表的前面，一般放置在参数列表的最后

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        // Error
        //def fun77(names:String*, name:String): Unit = {
            
        //}
        def fun777( name:String, names:String* ): Unit = {
            println( name )
            println( names )
        }
    }
}

• 可变参数的数据类型 就是常见类型后面加一个*
• 一个函数最多只能有一个可变参数

2) 参数默认值

• scala函数中的参数，相当于用val声明的局部变量，实参传递进去后，值是无法修改的
  
• 默认参数的用法

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

zhangsan,123123
zhangsan,000000

调用函数时，不传入这个参数，使用默认值；传入这个参数，默认值不起作用了

3) 带名参数

带名参数指在调用函数的时候，将参数名也带上

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

函数声明时的至简原则

• 注意，这里是在声明函数的时候，可以使用的至简原则；

• 至简原则，其实就是Scala的作者为了开发人员能够大幅度提高开发效率。通过编译器的动态判定功能，帮助我们将函数声明中能简化的地方全部都进行了简化。也就是说将函数声明中那些能省的地方全部都省掉。所以这里的至简原则，简单来说就是：能省则省。

• 省略了很多，最终是通过def关键字来判断这是个函数的！

1) 省略return关键字

如果明确返回值类型，可以省略return

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

2) 省略返回值类型

如果能够通过代码的逻辑推断出返回值类型，可以省略函数中声明的返回值类型;
不过IDEA工具会自动给你添加上返回值类型

object ScalaFunction {
    def main(args: Array[String])  = {
        def fun3() = {"zhangsan"}
    }
}

3) 省略花括号

当函数主题内容只有一行代码，可以省略花括号

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

4)省略小括号

当参数列表中没有声明参数，可以省略小括号

object ScalaFunction {
    def main(args: Array[String]): Unit = {
        def fun4 = "zhangsan"
        fun4// OK
        fun4()//(ERROR)
    }
}

如果函数声明的时候，省略了小括号，那么在调用的时候同样不能使用小括号！

5) 省略等号

如果函数体中有明确的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())
    }
}

省略等号，就是无论有没有返回值，此函数都没有结果；因此省略等号的函数叫做过程函数

6) 省略函数名

• 如果只关心函数实现逻辑，不关心逻辑，可以将关键字def和函数名都省略，但是省去了def，我们无法知道这是一个函数，因此，需要使用 =>

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


	(x:Int,y:Int):Int => {
		x+y
	} 

• 没有名称的函数叫做匿名函数；
• 匿名函数不能直接被使用，一般会赋值给变量来使用，这个变量可以简单地认为是函数名称

	val f = (x:Int,y:Int) => {x+y}
	println(f(10,20))

7）匿名函数的函数体问题

现象：

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

执行上面的代码的时候，xxxx并没有被打印出来
原因探查：
查看反编译：

解释：
匿名函数会将=>后面的所有内容当作一个整体放进方法体
解决方法：
用一个变量接收匿名函数

object ScalaFunction {
  def main(args: Array[String]): Unit = {
      val f = ()=>{"zhangsan"}
      println("xxxxxxxx")
  }
}

结果：
xxxxxxxx