概念及定义
在Scala当中，函数是一等公民，像变量一样，既可以作为函数的参数使用，也可以将函数赋值给一个变量. ，函数的创建不用依赖于类或者对象，而在Java当中，函数的创建则要依赖于类、抽象类或者接口
def 函数名 ([参数名: 参数类型], ...)[[: 返回值类型] =] {
语句... //完成某个功能
return 返回值
}
- 函数声明关键字为def (definition)
- [参数名: 参数类型], ...：表示函数的输入(就是参数列表), 可以没有。 如果有，多个参数使用逗号间隔
- 函数中的语句：表示为了实现某一功能代码块
- 函数可以有返回值,也可以没有
- 返回值形式1: // : 返回值类型 = 表示有返回值，并且指定了返回值的类型
- 返回值形式2: // = , 表示返回值类型，使用类型推导
- 返回值形式3: // 空的 ，表示没有返回值，即使有return 也不生效
- 如果没有return ,默认以执行到最后一行的结果作为返回值
object HelloScala {
def main(args: Array[String]): Unit = {
//使用方法
//先创建一个对象
val dog = new Dog
println(dog.sum(10, 20))
//函数, 求两个数的和
val f2 = (n1: Int, n2: Int) => {
n1 + n2 //函数体
}
println("f2=" + f2)
println("f2=" + f2(5, 6))
class Dog {
//方法
def sum(n1: Int, n2: Int): Int = {
n1 + n2
}
}
}
}
//1. 如果我们返回的类型是多种的，则推荐使用类型推导
def sum(n1: Int, n2: Int, oper: Char) = {
//判断
if (oper == '+') {
n1 + n2
} else if (oper == '-') {
n1 - n2
} else {
null
}
}
注意事项及细节
1.函数的形参列表可以是多个, 如果函数没有形参，调用时可以不带()
sayHello
def sayHello(): Unit = {
println("sayHello")
}
2.形参列表和返回值列表的数据类型可以是值类型和引用类型。
3.Scala中的函数可以根据函数体最后一行代码自行推断函数返回值类型。那么在这种情况下，return关键字可以省略
def sum(n1: Int, n2: Int): Int = {
// return n1 + n2
n1 + n2
}
4.因为Scala可以自行推断，所以在省略return关键字的场合，返回值类型也可以省略
def sum2(n1: Int, n2: Int) = {
// return n1 + n2
n1 + n2
}
5.如果函数明确使用return关键字，那么函数返回就不能使用自行推断了,这时要明确写成 : 返回类型 = ，当然如果你什么都不写，即使有return 返回值为()
// def sum3(n1:Int,n2:Int) = {
// return n1 + n2
// }
//如果你什么都不写，即使有return 返回值为()
def sum4(n1: Int, n2: Int) {
// return n1 + n2
return n1 + n2
}
6.如果函数明确声明无返回值（声明Unit），那么函数体中即使使用return关键字也不会有返回值
def sum5(n1: Int, n2: Int): Unit = {
// return n1 + n2
return n1 + n2
}
7.如果明确函数无返回值或不确定返回值类型，那么返回值类型可以省略(或声明为Any)
def f10(n: Int): Any = {
if (n == 1) {
10
} else {
"yes"
}
}
8.Scala语法中任何的语法结构都可以嵌套其他语法结构(灵活)，即：函数/方法中可以再声明/定义函数/方法，类中可以再声明类
val f11 = (s: String) => {
println("s=" + s)
val f12 = (s: String) => {
println("f12 s=" + s)
}
f12("yes")
}
9.Scala函数的形参，在声明参数时，直接赋初始值(默认值)，这时调用函数时，如果没有指定实参，则会使用默认值。如果指定了实参，则实参会覆盖默认值
def sayOK(s: String = "北京"): Unit = {
println("sayOk =" + s)
}
//9.测试
sayOK()
sayOK("深圳")
10.如果存在多个参数，每一个参数都可以设定默认值，那么这个时候，传递的参数到底是覆盖默认值，还是赋值给没有默认值的参数，就不确定了(默认按照声明顺序[从左到右])。在这种情况下，可以采用带名参数
//10测试
//mysqlCon("192.168.11.11")//错误，因为没有给port值
//使用命名参数来指定某个形参的值，这样就更灵活
mysqlCon("192,168.11.11", port = 8888)
def mysqlCon(add: String = "localhost", port: Int,
user: String = "root", pwd: String = "root"): Unit = {
println("add=" + add)
println("port=" + port)
println("user=" + user)
println("pwd=" + pwd)
}
11.scala 函数的形参默认是val的，因此不能在函数中进行修改.
12.递归函数未执行之前是无法推断出来结果类型，在使用时必须有明确的返回值类型
def f8(n: Int):Int = { //如果省略返回值类型则错误，递归不能使用类型推断，必须指定返回的数据类型
if (n <= 0)
1
else
n * f8(n - 1)
}
13.Scala函数支持可变参数，注意可变参数只能放在最后
def sum10(n:Int,args:Int*): Int = {
var res = n
for (i<-args) {
res += i
}
res
}
println(sum10(1,2,3)) //6
println(sum10(1,2,3,4,5)) // 15
过程
将函数的返回类型为Unit的函数称之为过程(procedure)，如果明确函数没有返回值，那么等号可以省略
注意区分: 如果函数声明时没有返回值类型，但是有 = 号，可以进行类型推断最后一行代码。这时这个函数实际是有返回值的，该函数并不是过程。
惰性函数
当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数，在Java的某些框架代码中称之为懒加载(延迟加载)
1 lazy 不能修饰 var 类型的变量
2 不但是在调用函数时，加了 lazy ,会导致函数的执行被推迟，我们在声明一个变量时，如果给声明了 lazy ,那么变量值的分配也会推迟
object LazyDemo {
def main(args: Array[String]): Unit = {
lazy val res = sum(1,2)
println("-----------------------")
println("res=" + res) //当需要使用到res时，就会真正的开始计算
}
//将来这个计算方法是非常耗费运力
def sum(n1:Int,n2:Int): Int = {
println("sum 被调用..")
n1 + n2
}
}
异常
try {
var res = 10 / 0
} catch {
case ex: ArithmeticException => {
println("算术异常=" + ex.getMessage)
println("111")
println("222")
}
case ex: Exception => println("异常信息=" + ex.getMessage)
} finally {
println("finaly的代码...")
}
def test(): Nothing = {
throw new Exception("不对")
}
