一. 函数参数的默认值

• 定义有默认值的函数

格式：

def 函数名(参数1：类型1=默认值1,参数2：类型2=默认值2)

• 定义一个函数，并使用不同的参数来测试使用。

def hello(name: String = "小明", age: Int = 17, gender: String = "女"): Unit = {
  println(s"hello，我是${name}，${age}岁，性别:${gender}")
}

def main(args: Array[String]): Unit = {
  hello("小花", 25, "女")
  hello("小明", 29, "男")
  hello("小招", 19) // 1. 不写性别，默认为女
  hello() // 2. 不写所有参数，全部使用默认值

  hello(age = 18) // 3.设置年龄为18，其他的参数使用默认值
  hello(gender = "男", name = "小李") // 4. 设置名字为小李，性别为男，年龄使用默认值
}

说明

默认值参数可以让函数调用更灵活。

调用时可以只传部分参数。未传入的部分会使用默认值。

结果如下：

二. 创建不带()的方法

如果函数没有参数，可以省略定义函数时的( )。

格式：

def 方法名:[返回类型]={}。

def test: Unit = {
  println("test.......")
}


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

  test  // 不用加()
}

说明

当方法没有参数时，定义时可以不写()。

调用时也可以直接写方法名。

结果如图：

三. 创建接受变参的方法

在Scala里，创建能接受变参的方法，形式为：参数类型* 。

这种方式有个限制，就是只能接受同一类型的参数哦。

问题：

怎样去定义一个函数，使其能够接收数量不固定的参数，然后对这些参数进行累加计算呢？

比如说：当调用getSum(1)时，得到的结果是1；而调用getSum(4,1,2,3,5)时，得到的结果是15。

// 允许参数的个数不同，类型相同
// 变参：参数类型后边，加一个*
def getSum(args: Int*): Int = {
  var sum = 0
  for (i <- args) {
    sum += i
  }
  sum
}

def main(args: Array[String]): Unit = {
  val result1 = getSum(1)
  val result2 = getSum(4, 1, 2, 3, 5)
  println(result1, result2)
}

要点总结

• 变参适合接收数量不固定的参数。
• 参数写法是：参数类型*。
• 变参只能接收同一类型的数据。

结果如图：

四. 案例

• 定义一个函数，判断给定的三个数字是否能构成一个三角形
• 判断一个数是不是素数

//  定义一个函数，判断给定的三个数字是否能构成一个三角形
def testTriangle(a: Double, b: Double, c: Double): Boolean = {
  a + b > c && a + c > b && b + c > a
}

// 判断一个数是不是素数
def isPrimeNum(num: Int): Boolean = {
  var isPrimeNum = true
  for (i <- 2 to num - 1) {
    if (num % i == 0) {
      isPrimeNum = false
    }
  }
  isPrimeNum
}

def main(args: Array[String]): Unit = {
  val r = testTriangle(1.0, 2.0, 2.0)
  println(r)

  val r1 = isPrimeNum(9)
  println(r1)
}

案例说明

第一个函数用于判断三个数字是否满足三角形的条件。

只要任意两边之和大于第三边，就可以构成三角形。

第二个函数用于判断一个数是不是素数。

它通过遍历2到num - 1之间的数字，判断是否存在能整除num的数。

结果如图：