【Kotlin】函数

已于 2025-02-28 23:25:29 修改
阅读量1.5k 收藏 17
点赞数 16
CC 4.0 BY-SA版权
分类专栏： Kotlin 文章标签： kotlin 函数 泛型 内联函数 inline 可变长参数函数 vararg
于 2024-03-01 01:03:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37602827/article/details/136180492
本文详细介绍了Kotlin中的各种函数类型（无参、有参、返回值、可变长参数），函数变量、匿名函数、内联函数以及泛型（包括单泛型、多泛型、协变、逆变和泛型边界）。还讨论了内联函数的reified关键字的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1 常规函数

1.1 无参函数

fun main() {
    myFun()
}

fun myFun() {
    println("myFun") // 打印: myFun
}

1.2 有参函数

        1）常规调用

fun main() {
    myFun("myFun") // 打印: myFun
}

fun myFun(str: String) {
    println(str)
}

         2）形参指定默认值

fun main() {
    myFun() // 打印: abc
}

fun myFun(str: String = "abc") {
    println(str)
}

         3）实参指定变量名

fun main() {
    myFun(b = 123, a = "abc") // 打印: abc123
}

fun myFun(a: String, b: Int) {
    println(a + b)
}

1.3 有返回值函数

        1）常规调用

fun main() {
    var c = add(3, 5)
    println(c) // 打印: 8
}

fun add(a: Int, b: Int): Int {
    return a + b
}

        说明：对于无返回值类型函数，其返回类型为 Unit，如下，也可以省略不写。

fun myFun(str: String): Unit {
    println(str)
}

         2）单行函数体简化

        当函数内部只有一行代码时，可以简化如下。

fun main() {
    var c = add(3, 5)
    println(c) // 打印: 8
}

fun add(a: Int, b: Int): Int = a + b

1.4 可变长参数函数（vararg）

        1）常规调用

fun main() {
    myFun("aa", "bb", "cc") // 打印: aa、bb、cc
}

fun myFun(vararg params: String) {
    for (str in params) {
        println(str)
    }
}

        说明：函数的可变长参数个数最多为 1 个。 

        2）使用数组接收可变长参数

fun main() {
    myFun("aa", "bb", "cc") // 打印: 3
}

fun myFun(vararg params: String) {
    var arr: Array<out String> = params
    println(arr.size)
}

        3）将数组传给可变长参数函数

fun main() {
    var arr: Array<String> = arrayOf("aa", "bb", "cc")
    myFun(*arr)  // 打印: 3
    myFun("xx", *arr, "yy")  // 打印: 5
}

fun myFun(vararg params: String) {
    println(params.size)
}

2 函数类型变量

2.1 函数类型变量

        1）无参函数变量

fun test() {
    println("test")
}

fun main() {
    var myFun: () -> Unit = ::test
    myFun() // 打印: test
}

        2）有参函数变量

fun test(a: Int, b: String): Unit {
    println("test, $a, $b")
}

fun main() {
    var myFun: (Int, String) -> Unit = ::test
    myFun(123, "abc") // 打印: test, 123, abc
}

        3）有返回值函数变量

fun test(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    var myFun: (Int, Int) -> Int = ::test
    println(myFun(3, 5)) // 打印: 8
}

2.2 匿名函数

        匿名函数即没有名字的函数，在声明函数变量时，可以指向一个匿名函数。

fun main() {
    var myFun: (Int, Int) -> Int = fun(a: Int, b: Int): Int {
        return a + b
    }
    println(myFun(3, 5)) // 打印: 8
}

        可以使用 Lambda 表达式简化如下。

fun main() {
    var myFun: (Int, Int) -> Int = { a, b ->
        a + b
    }
    println(myFun(3, 5)) // 打印: 8
}

3 内联函数（inline）

        内联函数是使用 inline 关键字修饰的函数，编译后会自动将函数体内的代码复制到调用处，以优化代码执行效率。

3.1 常规内联函数

        Test.kt

fun main() {
    myFun()
}

inline fun myFun() {
    println("内联函数")
}

        以上代码经过编译运行后，依次点击【Tools → Kotlin → Show Kotlin Bytecode】，生成字节码文件。

        再点击 DeCompile 按钮反编译字节码文件，会生成对应的 Java 文件。

public final class TestKt {
   public static final void main() {
      String var1 = "内联函数";
      System.out.println(var1);
   }

   public static void main(String[] var0) {
      main();
   }

   public static final void myFun() {
      String var1 = "内联函数";
      System.out.println(var1);
   }
}

        说明：可以看到 myFun 函数里的代码被复制到调用处了。 

3.2 带 return 的嵌套内联函数

        1）return 不带标签

fun main() {
    outFun {
        println("inFun")
        return // 等价于: return@main
    }
    println("main end") // 未打印
}

inline fun outFun(inFun: () -> Unit) {
    inFun()
    println("outFun end") // 未打印
}

        运行结果如下。

inFun

        "outFun end" 和 "main end" 未打印，这是因为内联函数会直接将 return 语句复制到 main 函数中。

        2）return@标签

fun main() {
    outFun {
        println("inFun")
        return@outFun
    }
    println("main end")
}

inline fun outFun(inFun: () -> Unit) {
    inFun()
    println("outFun end")
}

        运行结果如下。

inFun
outFun end
main end

4 泛型函数

        泛型的类型检查只存在于编译阶段，在源代码编译之后，不会保留任何关于泛型类型的内容，即类型擦除。

4.1 简单泛型函数

        1）单泛型参数

fun main() {
    myFun(123)  // 打印: 123
    myFun("abc")  // 打印: abc
    myFun(true)  // 打印: true
    myFun(null)  // 打印: null
}

fun <T> myFun(param: T) {
    println(param)
}

        2）多泛型参数

fun main() {
    var res: Boolean = myFun("abc", 123, true) // 打印: abc, 123
    println(res) // 打印: true
}

fun <R, T, S> myFun(a: T, b: S, c: R): R {
    println("$a, $b")
    return c
}

4.2 类中泛型函数

fun main() {
    var c1: MyClass<String> = MyClass()
    c1.myFun("abc") // 打印: abc
    var c2: MyClass<Int> = MyClass()
    c2.myFun(123) // 打印: 123
}

class MyClass<T> {
    fun myFun(a: T) {
        println(a)
    }
}

4.3 自动推断泛型类型

        Kotlin 提供了下划线（_）运算符可以自动推断类型。

fun main() {
    myFun<Int, _>()
}

fun <S : Comparable<T>, T> myFun() {
    println("test _")
}

        Int 类和 Comparable 类的定义如下。由于 Int 继承了 Comparable<Int>，因此会自动推断 "_" 为 Int。

public interface Comparable<in T>
public class Int private constructor() : Number(), Comparable<Int>

4.4 抗变、协变和逆变

        1）抗变

        如下，Int 是 Number 的子类，Number 引用可以指向 Int 对象，但是 Data<Number> 引用不能指向 Data<Int> 对象，Data<Int> 引用也不能指向 Data<Number> 对象，该现象称为抗变。

        2）协变

        通过 out 关键字表示 Data<Number> 引用能指向 Data<Int> 对象，类似于 java 中的 "? extends Number"。

class Data<T>(var value: T)

fun main() {
    var data1: Data<Int> = Data<Int>(1)
    var data2: Data<out Number> = data1
    println(data2.value) // 打印: 1
    // data2.value = 1 // 编译错误, setter方法被限制
}

        说明：协变后，不能修改协变元素。使用 out 修饰的泛型不能用作函数的参数，对应类型的成员变量 setter 方法会被限制，只能当做一个生产者使用。

        3）逆变

        通过 in 关键字表示 Data<Int> 引用能指向 Data<Number> 对象，类似于 java 中的 "? super Int"。

class Data<T>(var value: T)

fun main() {
    var data1: Data<Number> = Data<Number>(1f)
    var data2: Data<in Int> = data1
    println(data2.value) // 打印: 1.0
    data2.value = 2
    var a: Any ?= data2.value // 只能用Any接收value
}

        说明：逆变后，只能使用 Any 接收逆变元素。使用 in 修饰的泛型不能用作函数的返回值，对应类型的成员变量 getter 方法会被限制，只能当做一个消费者使用。 

        4）通配 *

        在有些时候，我们可能并不在乎到底使用哪一个类型，我们希望一个变量可以接受任意类型的结果，而不是去定义某一个特定的上界或下界。在Kotlin 泛型中，星号（*）代表了一种特殊的类型投影，可以代表任意类型。

class Data<T>(var value: T)

fun main() {
    var data1: Data<Int> = Data<Int>(1)
    var data2: Data<*> = data1 // Data<*>等价于Data<out Any>
    println(data2.value) // 打印: 1.0
    // data2.value = 2 // 编译错误, setter方法被限制
    var a: Any ?= data2.value // 只能用Any接收value
}

        说明：由于不确定具体类型，使用时只能是 Any 类型。 

4.5 泛型的界

        Kotlin 泛型中，可以为其指定上界。

        1）单上界

class Data<T: Number>(var value: T)

fun main() {
    var data1: Data<Int> = Data<Int>(1)
    // var data1: Data<String> = Data<String>("abc") // 编译错误, 指定了上界为Number
    var data2: Data<*> = data1 // Data<*>等价于Data<out Number>
    println(data2.value) // 打印: 1.0
    // data2.value = 2 // 编译错误, setter方法被限制
    var a: Number = data2.value // 可以用Number接收value
}

        2）多上界

open class A {}
interface B {}

class Data<T>(var value: T) where T: A, T: B

4.6 具化类型参数（reified）

        Kotlin 的内联（inline）函数可以使用 reified 关键字具化类型参数，允许在函数体内部检测泛型类型，因为这些类型信息会被编译器内嵌在调用点。但是，这只适用于内联函数，因为内联函数中的类型信息在编译时是可知的，并且实际类型会被编译到使用它们的地方。

        以下调用会编译报错。

         通过 inline 和 reified 修饰符，可以解决编译报错问题，如下。

inline fun<reified T> isType(value: Any) : Boolean {
    return value is T
}

fun main() {
    println(isType<Int>("abc")) // 打印: false
    println(isType<String>("abc")) // 打印: true
}
Kotlin函数和对象
天花板的随笔
02-19 846
扩展函数在语法上看起来就像是类的原生方法一样，但实际上是在类的外部定义，因此，它不能访问类的私有或受保护的成员，同时也不能在类的内部调用。拓展函数可以搭配高阶函数一起使用，组成拓展高阶函数。当函数被标记为inline时，表示这是一个内联函数，编译器会尝试在调用该函数的地方直接插入函数的实现代码，而不是生成调用函数的代码，从而消除函数调用的开销。在kotlin中函数也是有类型的，跟整型、字符串类型是同样的性质，函数类型就是将函数的“输入参数类型”和“返回值类型”的抽象表达，如（Int，Int）-> Int。
Android-kotlin-extend-utils:Kotlin 常用扩展函数总结
05-02
Kotlin 常用扩展函数总结 1.ImageViewExtends(Glide) 名称 描述 loadImage 加载图片 loadCircleImage 加载圆形图片 loadRoundCornerImage 加载圆角图片 loadImageByProportion 按照图片的宽高比加载 loadClear 取消加载 2.ViewExtends 名称 描述 view2Bitmap View 转 bitmap bottomMargin 底部Margin leftMargin 左侧Margin topMargin 上部Margin rightMargin 右侧Margin 3.TextViewExtends 名称 描述 setColor 设置颜色 setDrawableLeft 左侧Drawable setDrawableTop 上部Drawable setDrawableRight 右侧
Kotlin函数
欢乐斗佛的博客
10-18 667
函数是与我们打交道最多的，也是最复杂的一块，所以有必要单独的弄篇文章来详细的说明。比起Java中的函数，Kotlin的更为复杂，比如Kotlin还支持函数的扩展和单表达式函数，下面将详细的介绍。 定义一个函数 函数使用关键字fun来定义，格式如下： 【修饰符】fun 函数名字（参数）:返回值{ 函数体}，如 : open fun varaFun(vararg param:
kotlin常用函数
weixin_34235105的博客
11-20 164
repeat 代码块重复执行 repeat(3) { println("Hello world") } 复制代码with 对当前类操作，内部操作 with(ArrayList<String>()) { add("testWith") add("testWith") add("testWith") p...
kotlin函数
gengqiquan的博客
02-27 1027
infix标记法 在以下情况下，也可以使用中缀符号调用函数： 它们是成员函数或扩展函数-它们只有一个参数 它们用infix关键字标记 // Define extension to Int infix fun Int.shl(x: Int): Int { ... } // call extension function using infix notation 1 shl 2 // is the...
Kotlin 函数
秋殇阁
10-11 1339
kotlin中函数的定义是通过关键字fun来完成的。其基本的语法格式如下： fun funName(param : paramType,..) : returnType{ function body } 示例： fun printHello(username: String): String { print("Hi,$username ,Welcome to Kotlin!\n...
利用 kotlin 的方式自定义回调事件(kotlin函数参数)
08-19
Kotlin 自定义回调事件(kotlin 函数参数) 在 Android 开发中，回调事件是一种非常常见的编程方式，用于处理用户交互、网络请求等事件。在 Java 中，我们通常使用接口和匿名内部类来实现回调事件，但是这种方式往往...
【Kotlin编程】Kotlin函数详解：基础、进阶特性与应用场景全面解析Kotlin函数的各种
最新发布
04-05
适合人群：具备一定编程基础，特别是对Kotlin语言有一定了解的研发人员，尤其是那些希望深入了解Kotlin函数特性和优化代码质量的开发者。 使用场景及目标：①掌握Kotlin函数的基础和进阶特性，如局部函数、扩展函数...
Kotlin编程基础教程：Kotlin函数式编程
03-09
在Kotlin函数式编程中，可以利用这些核心概念进行高效的编程实践。在后续的章节中，将详细探讨Kotlin的类型推断、扩展函数、数据类、委托和协程的具体应用，以及如何在代码中实例化这些概念，并解答常见问题。
Kotlin函数默认值的完全讲解
08-26
Kotlin函数默认值的完全讲解 Kotlin函数默认值是Kotlin语言中的一种功能，它允许在函数定义时为参数指定默认值，从而简化代码的编写和维护。下面是Kotlin函数默认值的详细讲解。 Kotlin函数默认值的优点 相比Java...
kotlin函数_Kotlin函数
从零开始的教程世界
07-15 734
kotlin函数In this tutorial, we’ll be discussing at length, Functions in Kotlin. We’ll discuss everything you need to know about kotlin functions right from the syntax to the various implementations. 在本教...
Kotlin之函数
非猿
06-03 575
函数和方法指的是同一个东西 语法规则 fun（function的简写）是定义函数的关键字，无论定义什么函数，都需要用fun来声明 fun后面是方法名，可以随意起，但是编码规范要求最好有一定的意义，能知道这个方法是干什么的 方法名后面是一个括号，里面声明该函数接收什么参数，参数的数量是任意多个用逗号隔开，参数格式是 参数名：参数类型，其中参数名和方法名类似，可以随便定义。如果不接收任何参数，则只保留空括号即可 括号后面是可选的，用于声明该函数返回什么样类型的数据，格式为：参数类型，如果不返回任何数据，则不写
1.Kotlin函数大全
家驹六月天的博客
12-03 1282
1.Kotlin的基本使用
Kotlin系列四：标准函数、扩展函数、高阶函数、内联函数
许进进的博客
05-18 7921
目录 一 标准函数 1.1 let 1.2 with 1.3run 1.4apply 二扩展函数 2.1 扩展函数基本使用 2.2 运算符重载 2.3 最佳实践：扩展函数和运算符重载的合体 三 Kotlin高阶函数 3.1 基本定义 3.2三种用法 3.2.1双冒号 ::method 3.2.2 匿名函数 3.2.3 Lambda 表达式(常用) 四 内联函数inline 4.1noinline 4.2crossinline 一 标准函数 Kotl...
Kotlin（三）—— 函数
xingyu19911016的博客
03-17 3579
函数 1 函数定义 函数是用来运行代码的载体，可以在一个函数里编写很多行代码，当运行这个函数时，函数中的所有代码会全部运行。 Kotlin中的函数，语法规则如下： fun methodName(param1: Int, param2: Int): Int { return 0 } fun（function的简写）是定义函数的关键字，无论定义什么函数，都一定要使用fun来声明。 在fun后面的是函数名，这个就没有什么要求了，但是良好的编程习惯是函数名最好要有一定的意义，能表达这个函数的作用是什么。函
Kotlin基础-函数
luren123456的博客
08-16 354
函数 函数声明 与Java不同，Kotlin中使用fun关键字后跟函数名称来声明函数。“()”后的“:Int”表示返回值类型，如下： fun methodName(param1: Int, param2: Int): Int { return 0 } 参数默认值 Kotlin函数中参数可赋予默认值，如下： fun methodName(param1: Int = 0, param2: Int = 1) { println("param1 = $par
Kotlin语言基础之函数
u012167711的博客
04-27 641
您可以使用 fun 关键字在 Kotlin 中声明自己的函数。()(){}return如果函数没有返回任何有用的内容，则可以省略返回类型和return关键字。在中了解有关此内容的详细信息。xyxyxy在我们的编码约定中，我们建议以小写字母命名函数，并使用不带下划线的驼峰命名法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

little_fat_sheep

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值