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

文章目录

I . 函数类型
II . 带参数名的参数列表
III . 可空函数类型
IV . 复杂函数类型解读
V . 函数类型别名
VI . 带接收者类型的函数类型
VII . 函数类型实例化
VIII . 函数类型自动推断
IX . 带接收者的函数类型与不带接收者的函数类型之间的转换
X . 函数类型变量调用

I . 函数类型

函数类型格式 : 圆括号中定义 参数类型列表 , 使用 -> 由参数列表指向返回值类型 , 表示接受 参数类型列表 中的参数 , 返回 返回值类型 的返回值 ;

( 参数类型列表 ) -> 返回值类型

① 参数列表 : 参数类型的列表 , 多个参数类型使用逗号隔开 ;

② -> 符号 : 由参数列表指向返回值类型 , 该符号用于分割参数类型列表与返回值类型 ;

③ 返回值类型 : 只有一个返回值类型 ;

④ 示例 : (Int, Int)->Int 参数类型 , 表示该参数传入两个 Int 类型的参数 , 返回 Int 类型返回值 ;

II . 带参数名的参数列表

1 . 函数类型参数名称 : 参数列表中可以只是参数类型 , 也可以加上参数的变量名称 , 参数名称可以用于说明参数的含义 , 增加函数类型的理解性 ;

2 . 只有参数类型的函数类型 : 参数列表中只有参数类型 ;

( 参数类型1 , 参数类型2 , … 参数类型n ) -> 返回值类型

3 . 有参数名称的函数类型 : 参数列表中每个元素都由 参数名称 : 参数类型 组成 , 多个列表元素使用逗号隔开 ;

( 参数名称1 : 参数类型1 , 参数名称2 : 参数类型2 , … 参数名称n : 参数类型n ) -> 返回值类型

4 . 带参数名称的函数类型示例 :

① 没有参数名的函数类型 : (Int , String)->String ;

② 有参数名的函数类型 : (age : Int , name : String)->String ;

III . 可空函数类型

1 . 函数类型根据是否可空分类 : 函数类型与普通变量类型一样 , 也分为可空类型 , 非空类型两类 ;

2 . 默认非空类型 : 默认的函数类型都是非空类型 , 即函数定义时 , 需要对其进行初始化 , 或延迟初始化 ;

3 . 可空类型函数表示方法 : 可空的函数类型声明时 , 需要在函数类型外部加上括号 , 并在右侧添加 ? 可空符号 ;

( ( 参数列表 ) -> 返回值类型 ) ?

4 . 可空函数类型与非空函数类型示例 :

① 非空函数类型 : (Int , String)->String , 普通的函数类型 , 默认就是非空的函数类型 ;

② 可空函数类型 : ( (Int , String)->String ) ? , 在非空函数类型基础上 , 外层添加括号 , 右侧添加 ? , 该函数类型就变成了可空函数类型 ;

IV . 复杂函数类型解读

1 . 复杂函数类型 :

① 参数返回值是普通类型 : 如果函数的参数类型和返回值类型都是普通的类型还好 , 解读起来不是很困难 ;

② 参数返回值是函数类型 : 如果函数类型的参数类型或返回值类型中有函数类型 , 即嵌套的函数类型 , 这些函数类型很复杂 ;

2 . 右箭头 -> 符号的结合性 : 该符号是右结合的 , 解读时 , 先将第一个 -> 符号右边的值理解成返回值 , 再逐步解析 :

( Int , String ) -> ( Float , Double ) -> String

① 分析外层函数类型 ( 函数类型 ) : 首先根据右结合性 , 从左到右开始解读 , 读取到第一个 -> 符号 , 说明这是一个函数类型 , ( Int , String ) 是参数列表 , ( Float , Double ) -> String 是返回值类型 ;

② 分析内层函数类型 ( 外层函数的返回值类型 ) : 然后继续分析 ( Float , Double ) -> String 类型 , 外层的函数类型的返回值类型是一个函数类型 , 该函数类型参数列表是 ( Float , Double ) , 返回值是 String 类型 ;

③ 总结 : 这是函数类型的嵌套 , 外层函数类型的参数类型是 ( Int , String ) , 函数的返回值类型是 ( Float , Double ) -> String 是一个函数类型 ;

3 . 最佳实践 : 复杂的函数类型可读性很差 , 建议使用圆括号注明函数类型的结合性 , 层次 ;

( Int , String ) -> ( Float , Double ) -> String

这样表示虽然没有错误 , 也能读懂 , 但是该表示并不是一目了然 , 读懂理解也要花点时间 , 完全没有必要在代码中出脑筋急转弯题目 , 推荐加上圆括号 , 写成以下形式 :

( Int , String ) -> ( ( Float , Double ) -> String )

这样就可以一目了然 , ( Int , String ) 是参数列表 , ( ( Float , Double ) -> String ) 是返回值类型 , 该返回值类型是一个函数类型 ;

不推荐这种反人类的类型定义 , 建议还是以简洁为主 , 参考 C 语言的函数类型嵌套 int (*p) (int*, int (*f)(int*)) , C 语言的函数 + 指针类型嵌套 int (*(*p2)[5])(int*) , 这个需要根据复杂指针解读技巧慢慢解读 , 要花费很长时间才能搞懂 ;

V . 函数类型别名

使用 typealias 为函数类型声明一个别名 : 使用函数类型别名 , 能有效降低代码的复杂度 , 提高可读性 , 函数类型别名声明格式如下 :

typealias 别名 = 函数类型

代码示例 : 下面的示例中 , 为 (Int, Int) -> Int 函数类型声明了一个别名 , 该别名与函数类型的作用是一样的 ;

// 1 . 声明函数类型
typealias mathAdd = (Int, Int) -> Int// 2 . 为函数类型数理化
var add : mathAdd = {a : Int, b : Int -> a + b}// 3 . 为函数类型实例化
var add2 : (Int, Int) -> Int = {a : Int, b : Int -> a + b}fun main() {// 4 . 调用函数var result = add(1,2)println("$result")// 5 . 调用函数var result2 = add2(1,2)println("$result2")
}

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 = fun1fun main() {//"Tom".fun1(2) = TomTomprintln("\"Tom\".fun1(2) = ${"Tom".fun1(2)}")//fun2("Jerry", 2) = JerryJerryprintln("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(参数列表) 调用该函数 ;

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