scala入门：基础函数总结

2、基础函数学习

2.1函数定义

1、有参数无返回值

• 代码

  /**
    * 1、有参数无返回值
    * @param str
    */
  def say(str: String): Unit = {
  	println(s"say: ${str}")
  }
  
  println("1、有参数无返回值")
  say("hello world")
  println("---------------------------------------")
  

• 输出

  1、有参数无返回值
  say: hello world
  ---------------------------------------
  

2、有参数有返回值

• 代码

  /**
    * 2、有参数有返回值
    * @param code
    */
   def getCode(code: String): String = {
        return code
  }
  
  val code: String = getCode("SDD11005")
  println(s"2、有参数有返回值：${code}")
  println("---------------------------------------")
  

• 输出

  2、有参数有返回值：SDD11005
  ---------------------------------------
  

3、无参数有返回值

• 代码

  /**
    * 3、无参数有返回值
    * @return
    */
  def getName(): String = {
    return "sherry"
  }
  val name: String = getName()
  println(s"3、无参数有返回值：${name}")
  println("---------------------------------------")
  

• 输出

  3、无参数有返回值：sherry
  ---------------------------------------
  

4、无参数无返回值

• 代码

  /**
    * 4、无参数无返回值
    */
  def printStr(): Unit = {
    println("无返回值")
    return "sherry"
  }
  val result: Unit = printStr()
  println(s"4、无参数无返回值：${result}")
  println("---------------------------------------")
  println("---------------------------------------")
  

• 输出

  无返回值
  4、无参数无返回值：()
  ---------------------------------------
  

5、可变参数

• 代码

  /**
    * 5、可变参数
    *
    * @param args
    */
  def arrayFuc(args: String*): Unit = {
    println(args)
  }
  println(s"5、可变参数")
  arrayFuc("Jan", "sherry")
  arrayFuc()
  println("---------------------------------------")
  

• 输出

  5、可变参数
  WrappedArray(Jan, sherry)
  List()
  ---------------------------------------
  

6、多参数，包含可变参数

多个参数，可变参数一般放置在最后

• 代码

  /**
    * 6、多参数，包含可变参数
    * 多个参数，可变参数一般放置在最后
    *
    * @param name
    * @param args
    */
  def parameterArrFunc(name: String, args: String*): 
    println(name + args)
  }
  println(s"6、多参数，包含可变参数")
  parameterArrFunc("Jack", "No.001", "15")
  parameterArrFunc("Jack")
  println("---------------------------------------")
  

• 输出

  6、多参数，包含可变参数
  JackWrappedArray(No.001, 15)
  JackWrappedArray()
  ---------------------------------------
  

7、参数默认值

• 代码

  /**
    * 7、参数默认值
    * @param name
    */
  def defaultParFunc(name: String = "Alin"): Unit = 
    println(name)
  }
  println(s"7、参数默认值")
  defaultParFunc("Jack")
  defaultParFunc()
  println("---------------------------------------")
  

• 输出

  7、参数默认值
  Jack
  Alin
  ---------------------------------------
  

8、多参数，包含参数默认值

将有默认值的参数放置在参数列表的后面，
Scala 函数中参数传递是，从左到右

• 代码

  /**
    * 8、多参数，包含参数默认值
    * 将有默认值的参数放置在参数列表的后面，Scala 函数中参数传递是，从左到右
    *
    * @param name
    * @param stuClass
    */
  def parsDefaultFunc(name: String, stuClass: String = "cNo.2"): Unit = {
    println(name + " " + stuClass)
  }
  println(s"8、多参数，包含参数默认值")
  parsDefaultFunc("Jack")
  parsDefaultFunc("Jan", "cNo.6")
  def parsDefaultFunc01(stuClass: String = "cNo.2", name: String): Unit = {
    println(name + " " + stuClass)
  }
  // parsDefaultFunc01("panda") 报错
  parsDefaultFunc01("panda", "ccc")
  // 指定参数名称
  parsDefaultFunc01(name = "panda", stuClass = "cNo.10")
  println("---------------------------------------")
  

• 输出

  8、多参数，包含参数默认值
  Jack cNo.2
  Jan cNo.6
  ccc panda
  panda cNo.10
  ---------------------------------------
  

2.2函数至简

1、省略return 关键字

• 要求

  无要求，和python类似 省略return关键字 默认返回最后一行

• 代码

  println("return 可以省略，Scala 会使用函数体的最后一行代码作为返回值")
  /**
    * 省略return 关键字
    *  无要求
    *  和python类似 省略return关键字 默认返回最后一行
    * @return
    */
  def sayHello(): String = {
    "hello, Jan"
  }
  println(s"test01: ${sayHello()}")
  /**
    * 和python类似 省略return关键字 默认返回最后一行
    *  返回一个集合
    * @return
    */
  def sayHelloArr(): Seq[Int] = {
    for(i <- 1 to 10) yield i
  }
  println(s"test02: ${sayHelloArr()}")
  println("---------------------------------------")
  

• 输出

  return 可以省略，Scala 会使用函数体的最后一行代码作为返回值
  test01: hello, Jan
  test02: Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  ---------------------------------------
  

2、省略花括号

• 要求

  代码只有一行

• 代码

  /**
    * 省略括号
    *   要求： 代码只有一行
    *     如果函数体只有一行代码，可以省略花括号
    * @return
    */
  def testFunc01(): String = "hello, Jan"
  println(s"say: ${testFunc01()}")
  println("---------------------------------------")
  

• 输出

  如果函数体只有一行代码，可以省略花括号
  say: hello, Jan
  ---------------------------------------
  

3、省略返回值类型

• 要求

  返回值类型能够推断出来，且不包含return

  注意 ： 有return 必须有返回值类型

• 代码

  println("返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）")
  /**
    * 省略返回值类型
    *     要求：返回值类型能够推断出来，且不包含return
    *     返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    * @return
    */
  def testFunc02() = "hello, Jan"
  println(s"say: ${testFunc02()}")
  println("---------------------------------------")
  
  println("如果有 return，则不能省略返回值类型，必须指定")
  /**
    * 有return 必须有返回值类型
    * @return
    */
  def testFunc03(): String = {
    return "hello, Jan"
  }
  println(s"say: ${testFunc03()}")
  println("---------------------------------------")
  

• 输出

  返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
  say: hello, Jan
  ---------------------------------------
  如果有 return，则不能省略返回值类型，必须指定
  say: hello, Jan
  ---------------------------------------
  

4、返回值类型为Unit，那么函数返回值为 ()

• 代码

  /**
    * 返回值类型为Unit，那么函数返回值为 ()
    * @return
    */
  def testFunc04(): Unit = {
    return "hello, Jan"
  }
  println(s"say: ${testFunc04()}")
  println("---------------------------------------")
  

• 输出

  say: ()
  ---------------------------------------
  

5、省略等号

• 要求

  无返回值

• 代码

  println("Scala 如果期望是无返回值类型，可以省略等号")
  /**
    * 省略等号
    * 要求：无返回值
    */
  def testFunc05()  {
     "hello, Jan"
  }
  println(s"say: ${testFunc05()}")
  // 第二种调用方式
  println(s"say: ${testFunc05}")
  println("---------------------------------------")
  

• 输出

  Scala 如果期望是无返回值类型，可以省略等号
  say: ()
  say: ()
  ---------------------------------------
  

6、省略参数括号

• 要求

  无参数列表，且调用时小括号必须省略

• 代码

  /**
    *  省略参数括号
    * 要求：无参数列表，调用时小括号必须省略
    */
  def testFunc06  {
    "hello, Jan"
  }
  // println(s"say: ${testFunc06()}")
  // 只能使用不带括号调用方式
  println(s"say: ${testFunc06}")
  println("---------------------------------------")
  

• 输出

  say: ()
  ---------------------------------------
  

7、省略函数名（匿名函数）

• 要求

  无要求

• 代码

  println("如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略")
  /**
    * 省略函数名（匿名函数）
    *    无要求
    */
  val func = (name:String) => {
    println(name)
    name
  }
  val rel = func("ming")
  println(rel)
  println("---------------------------------------")
  

• 输出

  如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
  ming
  ming
  ---------------------------------------