菠萝菠萝卜的博客

Kotlin笔记06(标准函数和静态方法)

  • 2021-05-04
  • 作者 菠萝菠萝卜
  • ~3.38K 字
  • 次阅读
  1. 1. 标准函数with、run和apply
    1. 1.1. with
    2. 1.2. run
    3. 1.3. apply
  2. 2. 定义静态方法
    1. 2.1. companion object
    2. 2.2. 定义真正的静态方法
      1. 2.2.1. 注解
      2. 2.2.2. 顶层方法

标准函数with、run和apply

with

有两个参数，第一个参数传递一个对象，第二个参数是Lambda表达式，with会在lambda表达式中提供第一个参数对象的上下文，并且lambda表达式中最后一行代码作为返回值返回。

1
2
3
4
val result = with(obj){
    //obj的上下文
    "value" //返回值
}

作用：在多次调用一个对象的时候，让代码变得更加简洁

1
2
3
4
5
6
7
8
9
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val builder = StringBuilder()
builder.append("start eating fruits\n")
for(fruit in list){
    builder.append("${fruit}\n")
}
builder.append("Ate all fruits.\n")
val result = builder.toString()
println(result)

使用with之后

1
2
3
4
5
6
7
8
9
10
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val result = with(StringBuilder()){
    append("start eating fruits\n")
    for(fruit in list){
        append("${fruit}\n")
    }
    append("Ate all fruits.\n")
    toString()
}
println(result)

run

run函数和with是差不多的。只不过run函数是不能被直接调用的，需要用某个对象进行调用，run也是接受一个Lambda，并传入调用对象的上下文。其他和with一样

1
2
3
4
5
6
7
8
val result = StringBuilder().run {
    append("start eating fruits\n")
    for(fruit in list){
        append("${fruit}\n")
    }
    append("Ate all fruits.\n")
    toString()
}

apply

apply和run是极其类似的，都是在某个对象上使用，都是接受一个Lambda，但是能指定返回值，只会返回调用对象本身

1
2
3
4
5
6
7
8
val result2 = StringBuilder().apply {
    append("start eating fruits\n")
    for(fruit in list){
        append("${fruit}\n")
    }
    append("Ate all fruits.\n")
}
println(result2.toString())

定义静态方法

companion object

静态方法对于java来说是很简单的一件事，就是在方法上声明一个static

1
2
3
4
5
public class Util{
    public static void doAction(){
        System.out.println("do Action")
    }
}

Kotlin弱化了静态方法，因为Kotlin提供了一个更好的语法特性，那就是单例类。比如这个工具类，Kotlin推荐的是单例写法

1
2
3
4
5
object Util{
    fun doAction(){
        System.out.println("do Action")
    }
}

调用方式也是Util.doActioin()

但是如果我们只是希望一个类当中的某个方法变为静态方法怎么办呢？这就用到kotlin的companion object

1
2
3
4
5
6
7
8
9
10
class Util{
    fun doAction1(){
        System.out.println("do Action1")
    }
    companion object{
        fun doAction2(){
            System.out.println("do Action2")
        }
    }
}

doAction2()方法其实也并不是静态方法，companioin object 这个关键字实际上会在Util类的内部创建一个伴生类，而doAction2()方法就是定义在这个伴生类里面的实例方法。只是Kotlin会保证Util类始终只会存在一个伴生类对象，因此调用Util.doAction2()实际上是调用了Util的伴生类对象的doAction2()方法

定义真正的静态方法

Kotlin没有直接定义静态方法的关键字，只是提供了一些语法特征来支持类似静态方法的调用。因此用java调用Kotlin的静态方法时，会发现找不到这个方法。

这时就需要定义真正的静态方法了，两种方法：注解 和 顶层方法

注解

1
2
3
4
5
6
7
8
9
10
11
class Util{
    fun doAction1(){
        System.out.println("do Action1")
    }
    companion object{
        @JvmStatic
        fun doAction2(){
            System.out.println("do Action2")
        }
    }
}

注意：@JvmStatic注解只能加在单例类或者companion object中的方法上。

顶层方法

顶层方法：指的是那些没有定义在任何类当中的方法

Kotlin会将所有顶层方法全部编译成静态方法。首先创建一个Kotlin文件，比如Helper.kt文件，里面可以定义一个方法。

1
2
3
4
//Helper.kt
fun doSomething(){
    println("do something")
}

顶层方法都是编译成静态方法，那么怎么用它呢？

Kotlin当中：顶层方法可以在任意位置使用，直接调doSomething()就可以了。

java当中：因为java中没有顶层方法的概念，Kotlin编译器会自动创建一个 HelperKt的java类，doSomething就是以静态方法的形式定义在HelperKt类里面。这个类的名字就是 Kotlin文件的名字加上Kt。

tips: 看到这里的时候，我才发现定义真正静态方法的知识点，都忘了。之前代码里的笔记也没写过这部分。哈哈，这里就补上。:joy:

本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可
最后编辑：2021-05-05