【Kotlin】函数类型 ( 函数类型 | 带参数名称的参数列表 | 可空函数类型 | 复杂函数类型 | 带接收者函数类型 | 函数类型别名 | 函数类型实例化 | 函数调用 )（二）

VI . 带 接收者类型 的函数类型

1 . 带 接收者类型 的函数类型 : 函数类型 可以指定 接收者类型 , 格式如下 :

接收者类型.( 参数类型列表 ) -> 返回值类型

① 接收者类型 : 接收者类型 的含义是 , 这个接收者类型对象是 函数类型 实例的接收者 , 该对象拥有该函数 ;

② 上述的 函数类型 定义 表示 : 接收者类型 对象 , 调用 ( 参数类型列表 ) -> 返回值类型 函数类型的函数 , 传入 ( 参数类型列表 ) 类型的参数 , 将返回 “返回值类型” 的返回值 ;

③ 本质 : 实例化该 带接收者的函数类型 变量时 , 相当于为该接收者类型定义了一个扩展函数 ;

2 . 带接收者类型的函数类型示例 :

① 带接收者类型的函数类型 : String.(Int, Float)->String ;

② 示例类型解析 : 在 String 类型对象上 , 调用 (Int, Int)->String 类型的函数 , 在该函数中按照顺序传入 Int , Float 两个类型的参数 , 那么得到一个 String 类型的返回值 ;

VII . 函数类型实例化

函数类型 变量实例化 : 给 函数类型变量 进行赋值 , 可以赋值的类型有以下几种情况 ;

1 . Lambda 表达式 : 可以将 Lambda 表达式赋值给函数类型变量 ;

// 将 Lambda 表达式赋值给函数类型变量
var add1 : (Int, Int) -> Int = {a : Int, b : Int -> a + b}

2 . 匿名函数 : 匿名函数 可以直接赋值给 函数类型 变量 ;

// 将 匿名函数 赋值给函数类型变量
var add2 : (Int, Int) -> Int = fun (a : Int, b : Int) : Int {return a + b}

3 . 已声明的函数 : 已经声明的函数 , 可以直接赋值给函数类型变量 ; 这些函数可以是 顶层函数 , 成员函数 , 局部函数 , 扩展函数 ;

fun add(a : Int, b : Int) : Int {
    return a + b
}
// 将顶层的 add 函数赋值给 add3 函数类型变量 :: 用于获取顶层定义的函数
//  如果获取 类中定义的函数 , 可以使用 类名::函数名 获取
var add3 : (Int, Int) -> Int = ::add

4 . 函数变量 : 已经声明的函数类型属性 , 可以是顶层属性 , 成员属性 , 扩展属性 ;

/

/ 将 Lambda 表达式赋值给函数类型变量
var add1 : (Int, Int) -> Int = {a : Int, b : Int -> a + b}
// 将已经定义好的函数类型变量重新赋值给 另外一个函数类型明亮
var add4 : (Int, Int) -> Int = add1

5 . 函数类型 派生类 : 函数类型可以看做一个接口 , 类可以实现该接口 , 在实现类中实现具体的函数操作 , 该 函数类型接口的实现类 , 可以赋值给函数类型变量 ;

class AddOperation : (Int, Int) -> Int{
    override fun invoke(p1: Int, p2: Int): Int {
        return p1 + p2
    }
}
// 将 函数类型 接口派生类对象赋值给 函数类型变量
var add5 : (Int, Int) -> Int = AddOperation()

VIII . 函数类型自动推断

1 . 变量类型推断 : Kotlin 中的变量类型可以不用显示声明 , 可以根据其赋值的类型进行智能类型推断 ;

2 . 函数变量类型推断 : 函数类型变量也具有智能类型推断的性质 ;

var add = {a : Int, b : Int -> a + b}

上面的代码中省略了函数类型变量的函数类型 , 其赋值的 Lambda 表达式类型是 (Int, Int) -> Int 类型的 , 因此推断出 add 变量的函数类型是 (Int, Int) -> Int 类型的 ;

IX . 带接收者的函数类型 与 不带接收者的函数类型 之间的转换

带接收者的函数类型 , 可以转换为 不带接收者的函数类型 , 转换规则是 , 带接收者的函数类型的接收者 , 可以转换为不带接收者类型的第一个参数 ;

下面的两个函数类型是等价的 :

① 自带接收者的函数类型 : String.( Int ) -> String

② 不带接收者的函数类型 : ( String, Int ) -> String

带接收者函数类型 与 不带接收者函数类型 转换代码示例 :

// 字符串 "abc" 调用该函数 , 传入 2 参数 , 结果是 "abcabc"
var fun1 : String.( Int ) -> String = {times : Int -> this.repeat(times)}
// 这是将 接收者 设置成了第一个参数 , 将 String.( Int ) -> String 函数类型的变量 fun1 赋值给了
//  ( String, Int ) -> String 函数类型变量 
var fun2 : ( String, Int ) -> String = fun1
fun main() {
    //"Tom".fun1(2) = TomTom
    println("\"Tom\".fun1(2) = ${"Tom".fun1(2)}")
    //fun2("Jerry", 2) = JerryJerry
    println("fun2(\"Jerry\", 2) = ${fun2("Jerry", 2)}")
}

① 自带接收者的函数类型 : fun1 是带接收者的 函数类型 变量 , 其类型是 String.( Int ) -> String 类型 ;

② 不带接收者的函数类型 : fun2 是不带接收者的 函数类型变量 , 其类型是 ( String, Int ) -> String 类型 ;

③ 互相赋值 : 将 fun1 变量赋值给 fun2 变量 , 赋值成功 , 说明这两个变量类型是相同的 ;

④ 调用函数 : 分别调用 fun1 和 fun2 函数 , 调用结果相同 ;

执行结果 :

"Tom".fun1(2) = TomTom
fun2("Jerry", 2) = JerryJerry

X . 函数类型变量调用

函数类型变量调用 :

① invoke 调用 : 可以通过 函数类型变量名.invoke(参数列表) 调用该函数 ;

② 直接调用 : 也可以通过 函数类型变量名(参数列表) 直接调用该函数 , 将该变量名称当做函数名称来使用 ;