一、函式和方法的區別

1、核心概念

    （1）未完成某一功能的程式語句的集合，稱為函式。

    （2）類中函式稱之為方法。

例子：

 1 object functionAndMEthod {
 2   def main(args: Array[String]): Unit = {
 3     //定義函式
 4     def sayHi(name: String): Unit ={
 5       println("hi," + name)
 6     }
 7     //呼叫函式
 8     sayHi("wl")
 9 
10     //呼叫物件方法
11     functionAndMEthod.sayHi("wll")
 
12 
13     //獲取方法返回值
14     val result = functionAndMEthod.sayHello("xw")
15     println(result)
16   }
17 
18   //定義物件的方法
19   def sayHi(name: String): Unit ={
20     println("Hi," + name)
21   }
22 
23   def sayHello(name: String): String ={
24     println("hello," + name)
25     return "hello"
26   }
 
27 
28 }

編譯：

二、函式定義

1、無參，無返回值

//1、無參， 無返回值
    def f1(): Unit ={
      println("1、無參， 無返回值!")
    }
    f1()
    println(f1())

2、無參，有返回值

//2、無參， 有返回值
    def f2(): Int ={
      println("2、無參， 有返回值")
      return 22
    }
    println(f2())

3、有參， 無返回值

def f3(name: String): Unit ={
      println(
 
"3、有參， 無返回值" + name)
    }
    //輸出為（）
    println(f3("wl"))

4、有參， 又返回值

 //4、有參， 有返回值
    def f4(name: String): String ={
      println("4、有參， 有返回值" + name)
      return "hi" +name
    }
    println(f4("wll"))

5、多參， 無返回值

//5、多參， 無返回值
    def f5(name1: String, name2: String ): Unit ={
      println("5、多參， 無返回值" )
      println(s"${name1}和${name2}都是我")
    }
    println(f5("dw", "xw"))

6、多參， 又返回值

//6、多參， 有返回值
    def f6(a: Int, b: Int): Int = {
      println("6、多參， 有返回值")
      return a + b
    }
    println(f6(10, 12))

 三、函式引數

1、可變引數

//1、可變引數
    def f1(str: String*): Unit = {
      println(str)
    }
    f1("sy")
    f1("wl", "xw", "dw")

2、如果引數列表中存在多個引數，那麼可變引數一般放置在最後

//2、如果引數列表中存在多個引數，那麼可變引數一般放置在最後
    def f2(str1: String, str2: String*): Unit = {
      println("str1" + str1 + "str2" + str2)
      f2("syy")
      f2("aaa", "bbb", "ccc", "ddd")
    }

3、引數預設值，一般將有預設值的引數放置在引數列表的後面

//3、引數預設值，一般將有預設值的引數放置在引數列表的後面
    def f3(name: String = "xwtx"): Unit = {
      println("My name is :" + name)
    }
    f3("wl")
    f3()

4、帶名引數

//4、帶名引數
    def f4(name: String,age: Int): Unit = {
      println(s"${age}歲的${name}")
    }
    f4("wwll", 22)
    //打亂順序
    f4(age = 22, name = "wwl")

四、函式至簡原則

1、return可以省略，scala會使用函式體的最後一行程式碼作為返回值

def f1(name: String): String = {
      name
   }
    println(f1("wl"))

2、如果函式體只有一行程式碼，可以省略花括號

//2、如果函式體只有一行程式碼，可以省略花括號
    def f2(name: String): String = name
    println(f2("wl"))

3、如果返回值的型別能夠推斷出來，那麼可以省略（：和返回值型別一起省略）

def f3(name: String) = name
    println(f3("wl"))

4、如果有return，則不能省略返回值型別，必須指定

5、如果函式宣告Unit，那麼即使函式體使用return關鍵字也不起作用

6、scala如果期望是無返回值，可以省略等號

def f6(name: String) {
      println(name)
    }
    println(f6("wl"))

7、如果函式無參，但是聲明瞭引數列表，那麼呼叫時，小括號可加可不加

def f7(): Unit = {
      println("wll")
    }
    f7

8、如果函式沒有引數列表，那麼小括號可以省略，呼叫時小括號必須省略

def f8: Unit = {
    }
    f8

9、如果不關心名稱，只關心邏輯處理，那麼函式名（def）可以省略

def f9(name: String): Unit = {
      println("wll")
    }
        //匿名函式，或者叫lambda表示式
    (name: String) => {println(name)}

五、匿名函式的簡化原則

val fun = (name: String) => {println(name)}
    fun("wl")

    //定義一個函式，以函式作為引數輸入
    def f(func: String => Unit): Unit = {
      func("wll")
    }
    f(fun)

1、引數的型別可以省略，會根據形參進行自動的推導

f( (name) => {
      println(name)
    })

2、型別省略之後，發現只有一個引數，則圓括號可以省略，沒有引數和引數超過1的永遠       不能省略圓括號

f( name => {
      println(name)
    })

3、匿名函式如果只有一行，則大括號也可以省略

f( name => println(name))

4、如果引數只出現一次，則引數省略且後面引數可以用 _ 代替

f(println(_))

5、如果可以推斷出當前傳入的println是一個函式體而不是呼叫語句，可以直接省略下劃線

f(println)

例子：

//實際示例： 定義一個“二元運算”函式，只操作1和2兩個數，但是具體運算通過引數傳入
    def OneAndTwo(fun: (Int, Int) => Int): Int ={
      fun(1, 2)
    }

    val add = (a: Int, b: Int) => a + b
    val minus = (a: Int, b: Int) => a - b
    println(OneAndTwo(add))
    println(OneAndTwo(minus))

    //匿名函式簡化
    println(OneAndTwo(_+_))
    println(OneAndTwo(_-_))