Kotlin——初級篇（七）：函數（方法）基礎總結

時間 2019-11-09

標籤 kotlin 初級函數方法基礎總結简体版

原文原文鏈接

對於Kotlin中的函數來講，和JavaScript或者Lua這些語言很像，它有着這些語言的特性。可是也與這些語言就着許多不一樣之處。或許你更瞭解Java語言，然而對於Java語言來講，它不是否是閉包這個特性的。因爲在這篇文章主要是講解函數的基本使用，故而只會講解到函數的定義、函數的返回值、函數的參數等。剩下的部分我會在這個系列的高級篇會給你們奉上。html

1、函數的聲明及基本使用

在Kotlin中函數的聲明，同JavaScript類似。git

1.一、函數的聲明

Kotlin中的函數聲明關鍵字爲：fun

定義格式爲：可見性修飾符 fun 函數名(參數名：類型,...) : 返回值{}

這裏的可見性修飾符請參見個人另外一篇文章Kotlin——中級篇（三）：可見性修飾符詳解，至於返回值以及參數請繼續往下面看github

例：定義一個最基本的函數編程

fun basis(){
    ...
}

注意：數組

上面的例子中沒有可見性修飾符，那是由於Kotlin中默認爲public可見性修飾符

()圓括號必須存在，即便是沒有參數的狀況下

{}大括號必須存在，即便是沒有函數體的時候，不過在Kotlin中有一個特例就是，函數具有返回值的時候，若是隻用一個表達式就能夠完成這個函數，則可使用單表達式函數。在下面會詳細的給你們講解

在函數沒有返回值時能夠省略其返回值

1.二、成員函數

成員函數是指在類或對象中的內部函數。你能夠參見個人另外一篇文章Kotlin——中級篇（一）：類（class）詳解閉包

例：聲明一個類，在類中在定義一個方法，這個方法就是這個類的成員函數編輯器

class Test{
    fun foo(){}
}

1.三、函數的使用

函數的使用分爲兩種：ide

普通的使用

成員函數的使用

例：函數

// 普通的使用
basis()
// 若是函數有返回值
val x = basis()

// 成員函數的使用：先初始化對象，在根據對象使用`中綴符號(.)`調用其成員函數
Test().foo()
// 若是函數有返回值
val x = Test().foo()

2、函數的返回值

在Kotlin中，函數的返回值類型能夠分爲：code

Unit類型：該類型即無返回值的狀況，能夠省略。

其餘類型：顯示返回類型的狀況

2.一、Unit類型

這個類型能夠理解爲函數無返回值。

例：

fun unitFun() : Unit{
    println("我是返回值爲Unit的函數，Unit可省略")
    return
    
    // return Unit 可省略
    // 或者 return  可省略
}

等價於

 fun unitFun(){
    println("我是返回值爲Unit的函數，Unit可省略")
}

當無返回值時，使用平時Java語法寫普通函數同樣便可。不需顯示寫成Unit。這裏只是作一個介紹而已

2.2 、其餘顯示返回類型的返回值

這個類型能夠理解爲，該函數具備返回值，而且返回值類型不能省略，而且return也不能省略

例：定義一個返回類型爲Int的函數

fun returnFun() : Int{
    return 2
}

3、函數的參數

對於函數中的參數來講，這裏主要分爲幾個模塊來說解：

具備參數的基本函數聲明

默認參數，即參數具備默認值

命名參數，當傳遞參數的時候顯示使用參數名 = 參數值

可變數量的參數：即參數的個數不定。

3.一、具備參數的函數定義

定義一個具備參數的函數，使用Pascal表示法定義，即爲:name : type。其中的參數必須具備顯示的參數類型，而且參數與參數之間用逗號(,)隔開。

例：

fun funArgs(numA : Int, numB : Float){
    println("numA = $numA \t numB = $numB")
}

fun main(args: Array<String>) {
    funArgs(1,10f)
}

3.二、默認參數

對於默認參數，即便指一個函數中的參數具備默認值，這樣在使用該函數的時候，能夠省略一部分參數，能夠減小函數的重載

例：定義個具備默認參數的函數

fun defArgs(numA : Int  = 1, numB : Float = 2f, numC : Boolean = false){
    println("numA  =  $numA \t numB = $numB \t numC = $numC")
}

fun main(args: Array<String>) {
    
    // 默認參數的函數使用
    defArgs()
    defArgs(1,10f,true)
}

輸出結果爲：

numA  =  1   numB = 2.0      numC = false
numA  =  1   numB = 10.0     numC = true

能夠看出：當具備默認參數時，能夠對是參數有默認值的參數不傳遞參數值。

不過這裏有一點值得注意的是：當該函數是一個成員函數時,而且該函數時覆寫繼承類中的方法時，則該成員函數必須從簽名中省略該函數的默認值。其實這一點沒必要過於看重，由於在你覆寫方法時，編輯器都默認會幫你實現的..

舉例說明：

open class A{
    open fun foo(i : Int = 10){}
}

class B : A(){
    override fun foo(i: Int) {
        super.foo(i)
        println(i)
    }
}

fun main(args: Array<String>) {
    B().foo()
}

輸出結果爲：10

若是你對類繼承不瞭解，能夠參見個人另外一篇文章Kotlin——中級篇（四）：繼承類詳解

3.三、命名參數

即在使用函數時顯示使用參數名 = 參數值這種方式傳遞參數

例：這裏舉例一個普通的具備參數函數與具備默認參數函數的結合使用

fun callFun(str : String, 
        isTrue : Boolean = false,
        numA : Int = 2,
        numB: Float = 2.0f,
        numC : Int = 2){}

能夠看出，上面實例中的str參數是不具有默認值的。

咱們能夠這樣使用它：

callFun("str")  // 這樣是能夠的，由於後面的參數都具備默認值

當使用非默認參數調用它時，使用起來就和Java函數同樣：

callFun("str",true,2,2.0,2)   // 這樣閱讀性不好，由於你除了看函數的定義外，你不知道這些參數的含義

使用命名參數咱們可使代碼更具備可讀性：

callFun("str",isTrue = true,numA = 3, numB = 3.0f, numC = 3)

當咱們不須要全部的參數時：
```
callFun("str",isTrue = true)
```

不過當咱們使用命名參數時，雖然能夠提升代碼的閱讀性，及在咱們使用第3、4時有一個坑，就是Java中不支持這種寫法的。而在實際的項目開發中，幾乎上都是和Java語言混用的。那麼這種用法就不適合了。全部這裏仍是推薦使用1、2兩點的用法。這是隻是介紹Kotlin的這種便利性而已。

3.四、可變數量參數

當一個函數中的參數是不定數量的個數而且是同一個類型，則但是使用vararg修飾符去修飾這個變量，則被vararg修飾的參數至關於一個固定類型的數組。

聲明格式：fun 函數名(vararg 參數名：類型，...) ：返回值{}

例：

fun varargFun(numA: Int, vararg str : String){
    // ...
}

其中，既然vararg修飾的變量至關於一個固定類型的數組，則咱們能夠對它進行一些高級的操做。這裏只舉例一些簡單的用法，若是你有興趣，能夠參見個人另外一篇文章Kotlin——高級篇（五）：集合之經常使用操做符彙總

例：

fun varargFun(numA: Int, vararg str : String){
        // 遍歷
    for (s in str) {
        
    }

// 獲取元素
//    str[index]
//    str.component1() ... str.component5()

// 或者其高階函數用法
//    str.map {  }
//    str.filter {  }
//    str.sortBy {  }

}

在傳遞參數值時，咱們能夠一個一個參數的傳遞，或者能夠直接傳遞一個當前定義類型的數組。不過在傳遞數組時，請使用伸展操做符( * )。

例：

普通傳遞 : varargFun(1,"aaa","bbb","ccc","ddd","fff")
數組傳遞：
        val strArray = arrayOf("aaa","bbb","ccc","ddd","fff")
        varargFun(1,*strArray)

4、單表達式函數

上面提到了單表達式函數。這裏詳細的講解一下。由於在結構體很是簡單的狀況下，使用單表達式函數仍是能提升代碼的閱讀性的，而且能夠少些兩行代碼。

單表達式函數：即函數具有返回值的時候，能夠省略花括號而且在=賦值符號以後指定代碼體，而函數的返回值是有編輯器自動推斷的。

例：

// 無參數的狀況
fun test1() = 2                     // 自動推斷爲：返回類型爲Int

// 有參數的狀況
fun test2(num : Int) = num * 2      // 自動推斷爲：返回類型爲Int

// 或者
fun test3(x : Float, y : Int = 2) = x * y  // 和默認參數一塊兒使用，返回值爲Float型

fun main(args: Array<String>) {
    println(test1())
    println(test2(2))
    println(test3(2f))
}

輸出結果爲：