11函数的基本使用

一导入

Scala既是一个面向对象编程的语言，也是一个面向函数编程的语言。Scala中的函数和方法的语法是相同的，只是意义不同。Java中并没有函数和方法的区分，因为Java是面向对象编程的语言。

二讲授新课

从不同的角度理解Scala函数会有不同的定义，如果一个函数作为某一对象的成员，那么这种函数就称为方法。如果从面向函数的角度理解Scala函数，那么Scala函数会具有面向函数式编程的特性。

(一）定义函数

格式如下：

（二）函数调用

[格式]：返回值=函数(参数)

两数求和

object base38 {
  // 定义一个函数
  // 1、位置：可以写在 main 里面，也可以写在外面
  // 2、要点// 返回值的类型
  // 省略 return
  // 返回值：可以省略 return
  def max(x: Int, y: Int): Int = {
    if (x > y) {
      x
    } else {
      y
    }
  }
  def main(args: Array[String]): Unit = {
    //调用函数
    val s = max(10, 20)
    println(s);
  }
}

结果如图;

(三）函数规则

1.只有一行可以省略{}。当Scala的函数体中只有一行表达式时可以省略{}，输出结果依然不变。

2.最后一条语句为函数的返回值。当函数体中有多个语句存在时，返回最后一条语句的值。

3.函数的返回类型可以省略。它会自动推断。

4.函数没有形参，在定义函数时可以省略()，那么在调用函数

object base38 {
  // 定义一个函数
  // 1、位置：可以写在 main 里面，也可以写在外面
  // 2、要点
  // 返回值的类型
  // 省略 return
  /*
  特别的写法
  1、没有参数列表，可以省略掉定义函数时的 ()，那么调用的时候，也不需要再加上 ()
  2、函数的最后一条语句的值就是返回值
  3、如果函数体只有一句
  */


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

  def getSum(x: Int, y: Int): Int = x + y

  def dosomething: Int = {
    println("xxxx")
    "11"
    1
  }

  // 返回值，可以省略 return
  def max(x: Int, y: Int): Int = {
    if (x > y) {
      x
    } else {
      y
    }
  }
  def main(args: Array[String]): Unit = {
    dosomething
    println(getSum(1, 2))

    // 调用函数
    val s = max(10, 20)
    println(s)
  }
}

结果如图：

提问：改造代码，求三个数的最大值？

object base39 {
    /**
     * 定义一个函数，求三个数中的最大值
     */
    def max (x:Int, y:Int, z:Int):Int = {
      // if (x >= y && x >= z) {
      // x
      // } else if (z >= y && z >= x) {
      // z
      // } else {
      // y
      // }
      val c = if (x > y) {
        x
      } else {
        y
      }
      if (c > z) { c } else { z }
    }
  /**
   定义一个函数，求三个数中的最小值
   */
  def min (x:Int, y:Int, z:Int):Int = {
  val c = if (x < y) { x } else { y }
  if (c > z) { z } else { c }

  }
  def main (args: Array [String]): Unit = {
    // 调用函数
    val s = max (100,100,100)
    println (s);
    val m = min(1,10,100)
    println(m);
     }
}

结果如图：

（四）函数返回多个值

object base40 {
    /**
     * 定义一个函数，返回三个数中的最大值和最小值
     */
    def getMaxandMin(x: Int, y: Int, z: Int): (Int, Int) = {
      var min: Int = x
      var max: Int = x

      min = if (x < y) { x } else { y }
      min = if (min < z) { min } else { z }

      max = if (x < y) { y } else { x }
      max = if (max < z) { z } else { max }

      // println(min, max)
      (min, max)
    }

    def main(args: Array[String]): Unit = {
      // 调用函数
      val r = getMaxandMin(10, 20, 3)
      println(s"最小值${r._1}")
      println(s"最大值${r._2}")
    }


}

结果如图：

（五）元组

元组:

表示不同类型值的集合，即元组可以用于存放不同类型的元素，例如可以存放整型、字符串、浮点型、自定义类型等等。Scala的元组类型可以使方法同时返回多个值，省略了中间部分的解析和集合的遍历。

定义元组:

第一种表示方式为：（元素1，元素2，…元素N）

第二种表示方式为：new TupleN（元素1，元素2，…元素N）。N最大为22

访问元组

元组通过Tuple_INDEX的方式访问元组中的元素，Tuple表示元组，INDEX表示索引。