怎么样编写地道的Kotlin代码

Posted 2022-01-02 ihrthk

怎么样编写地道的Kotlin代码

今天我打算谈论一下怎么编写地道的(Idimo)Kotlin代码，『地道』意思就符合Kotlin代码的习惯。我今天要讲的是如何摆脱Java编码习惯，开启你的Kotlin的编码风格。

好，我准备了一个代码Demo。

1.类的声明Bean(String name, int age)

这是用Java声明了一个Bean，它包含两个域name和age

public class Bean 
    private final String name;
    private final int age;

    public Bean(String name, int age) 
        this.name = name;
        this.age = age;
    

    public String getName() 
        return name;
    

    public int getAge() 
        return age;
    

对应的Kotlin代码应该这样写

class Bean2 
    private var name: String
    private var age: Int

    constructor(name: String, age: Int) 
        this.name = name
        this.age = age
    

    fun getName(): String 
        return name
    

    fun getAge(): Int 
        return age
    

我们中许多人是通过Java编程语言建立的知识来编程的。Kotlin是受到多种语言的启发，包括Java语言，所以这么写是可以正常工作的。但我们『绝对不应该』这么写Kotlin代码。

那么你是实际上应该做的是把所有的不必要的东西。我想说的是这个类，有两个属性，仅此而已。（这个类有一个主构造器，两个属性参数）

class Bean3(val name: String, val age: Int)

Kotlin演示了声明一个类是如此的简单。

2.数据类data class

看下这个代码，它表示解析一个名字，把它的firstName和lastName放到容器里。因为我没有办法，在一个函数里返回两个值，我不得不把它打包放进一个对象里。

fun parseName(name: String): List<String> 
    val space = name.indexOf(" ")
    return listOf(
        name.substring(0, space),
        name.substring(space + 1)
    )


fun main(args: Array<String>) 
    val name = parseName("Jane Doe")
    val first = name[0]
    val last = name[1]

    println("$first $last")
    if (name == parseName("Jane Doe")) 
        println("Equals is work")
    

我在这里滥用List容器，然后笨拙地把firstName和lastName都放进容器里。
事实上，即使用任何编程语言，你不应该这么写代码。

但是有一些现实的原因，我们可能会这样做。那就是：声明一个类的成本是很高的！

你需要找到一个合适package，然后创建一个文件，最后在里面写很多代码。

在Kotlin中，你不在需要这样做。你仅仅通过这样一行代码，
声明一个FullName类，它有first和last两个属性就可以了。

class FullName(val first: String, val last: String)

写一个类是简单的，节约了你很多时间，也节约了你的脑力劳动。
你可以在一个文件里声明多个类，它也不不会花费你任何东西。

我现在运行这个代码，发现它们是不相等的，因为我没有重写equals方法和hashCode方法。它是如此繁琐的，在Kotlin中，你真的不需要这样做。
因为你可能知道有一种叫做数据类的东西，在class前面加一个data就可以了。
编译器会帮我们生成equals和hashCode方法(还有copy和toString方法)。

写一个类是麻烦的这样的想法，在Kotlin是需要改变一下了。

3.属性

我们已经谈论了类，现在我们讲属性，然后是讲函数。

private var prop: String = "..."
fun getProp() = prop
fun setProp(v: String) 
    println("New value $v")
    prop = v

刚才我已经给你展示是了，用一行代码生成get和set方法。也就是在Kotlin中不需要写getXXX和setXXX方法。

如果你想要自定义seter方法，你也不需要为此单独声明一个函数，因为你可以使用『属性语法』。代码如下：

private var prop: String = "..."
    set(value) 
        println("New value $value")
        field = value
    

在这个自定义里面，你有filed，但是不需要域去存储，你也不用声明额外的名字，是的，就是这么简单直接！

4.属性委托

看一下这个代码：

private var _os: String? = null
val os: String
    get() 
        if (_os == null) 
            println("Computing...")
            _os = "android 12"
        
        return _os!!
    

这里已经有一些合理的逻辑，我有两个属性，一个是可空私有，另一个是不可空公有。

我第一次访问时，我检查它是否为空，然后计算一个值并写入其中，然后我输出它。

因此，这是什么呢？是的，这就是属性懒加载。

大家在Java语言中，写过很多这样的代码，这样的代码是很无聊的，这就是为什么Kotlin有一种机制叫做属性委托。所以委托属性让你摆脱这些的重复懒加载的逻辑。

代码如下：

val os: String by lazy 
    println("Computing...")
    "Android 12"

这个属性不是简单的初始化。这是委托给这个lazy。在第一次访问时，这个
Lambda将被执行。然后这个值会被储存起来，以便下次访问会使用。

这个lazy不是关键字，它仅仅是一个库函数，你可以定义你自己的。

5.自定义属性委托

这里有一种像观察者的属性，有些东西被修改，你将会被通知到。
你可以使用库函数，也可以自己实现。在这里使用了一个delegates.observable的库函数去完成这个工作。

var observeMe by Delegates.observable("a")  p, old, new ->
    println("$p.name goes $old -> $new")


fun main(args: Array<String>) 
    println("Observable property:")
    observeMe = "bb"
    observeMe = "ccc"
    observeMe = "dddd"

但是如果你喜欢，你不想这么写代码，你可以自己实现一个。

自定义属性委托，就是声明一个类它封装了你的属性的逻辑，比如geter方法和setter方法。

你现在可以简单地引用这个类在许多属性中，获取您的业务逻辑数据库访问，以及各种验证。

你可以把这个做成一个库，重用到在你的项目上。

这里举一个库例子：
https://github.com/MarcinMoskala/PreferenceHolder

var canEatPie: Boolean by bindToPreferenceField(true)

你实际上应该这么做，我确定你能够从中收益的。

6.函数

现在，我们开始讨论一下函数，函数是非常重要的，因此看一下下面这个代码：

class StringUtil 

    fun getFirstWorld(s: String, separator: String): String 
        val index = s.indexOf(separator)
        return if (index < 0) s else s.substring(0, index)
    

    fun getFirstWorld(s: String) = getFirstWorld(s, " ")


fun main(args: Array<String>) 
    println(StringUtil().getFirstWorld("Jane Doe"))

这个代码是非常糟糕的，请不要在Kotlin中这样写代码。

这是受我们Java编程习惯的启发，我们不得不把所有的东西都放进class里，因此就有了StringUtil。
你们写过有自己的StringUtil吗？oh,如果没有的话，那一定是一个新项目。

但是在Kotlin中，这里有点不同。你不需要使用一个类把这些方法或者属性包裹起来。

1. 首先，Kotlin类没有静态，因此为了使用这些函数，我们不得不每次都new一个StringUtil对象。我不想每次都new一个对象，所以类转换为对象。这个代码有了一点提高。
2. 事实上，我不需要一个对象，通过一个类就可以调用这个函数。在Kotlion中，我们有顶层函数。现在已经很像Kotlin代码了。
3. 但是它不是很好的Kotlin代码，因为这里有两个重载。所以getFirstWord假设要解析字符串，找到第一个空格，然后取第一个单词，然后返回它。但是如果分隔符不是空格，而是逗号什么的?所以，这里有全功能的版本。我想表达的是这里只是一个默认值。在Java中，我们不得不使用重载来模拟。在Kotlin中，直接指定默认值就好了。当你有很多默认参数不同的值，比如多个布尔值，等等。你可以只使用命名参数语法来表示您实际需要的。并且剩余其他的继续使用默认值。现在代码更少了，有更强的表现力。
4. 现在的代码，介于Java风格和Kotlin风格中间的状态，因为，这个函数的范围应该是String，而不是全局的。最好是把这个函数，放进String类里面去。Oh不，你不能控制String，你无法把任何东西放进这个类里。并且，你真的应该保持String类的api最小化。但是我真想要String有一个函数叫做getFirstWorld，那怎么办呢？在Kotlin中，有扩展函数去完成。这个只是在语法上给String添加了额外的函数，实际上你没有改变JDK里面String类的源码。我现在手动演示一下，它是怎么工作的！因为，我有一个接受者类型String，我不在需要这个参数了。我可以说这个点这里，或者省略所有在左边这些。现在我能使用它了。
5. 同时我也能扩展属性来去做。事实上，用扩展属性来做会非常好。

就是这样，因此，扩展函数和扩展属性，是非常重要的。这不仅仅是方便，它可以让你保持你类的API最小化，并且充满无限想象。

现在你看下Kotlin的String类，它仅有5个函数，相比较Java一屏又一屏的方法，简洁的太多了。并且所有的工具函数可以都可以是扩展，可以把这些函数放在不同的库里面，这样就把String类也做到了模块化。

这样做是对于工具类api设计是非常重要的。

7.遍历树

现在看一下这个代码：在这里，我编写的一个非常典型遍历树的代码。我有个容器和叶子元素。容器可以嵌套其他的，而叶子元素持有文字。我要取出这个结构中所有的的文本。

因此我定义三个类，Element，Container和Text。Container可以包含很多Element，而Text可以持有文本。

现在，我要遍历这个。所以我使用扩展函数。我用的是顶级函数，我前面说过的。
这都是正确的，但是我不喜欢这个代码，为什么呢？

fun main(args: Array<String>) 
    val root = Container(
        Text("a"),
        Container(
            Text("b"),
            Container(
                Text("c"),
                Text("d")
            ),
            Text("e")
        ),
        Text("f")
    )
    println(root.extractText())


abstract class Element

class Container(vararg val children: Element) : Element()
class Text(val text: String) : Element()


fun Element.extractText(): String 
    return extractText(this, StringBuilder()).toString()


fun extractText(e: Element, sb: StringBuilder): StringBuilder 
    if (e is Text) 
        val text = e as Text
        sb.append(text.text)
     else if (e is Container) 
        val container = e as Container
        for (child in container.children) 
            extractText(child, sb)
        
     else 
        throw Exception("Unrecognized element:$e")
    
    return sb

1. 这里，为了遍历层次结构，我需要递归。我需要传递stringBuilder沿着堆栈向下。
2. 然后是顶层函数，这个不是在函数内部之外的任何地方都需要。所以我想
   就是把它放进里面去。

把这两个问题修改好，就是这样的。

fun Element.extractText(): String 
    val sb = StringBuilder()
    fun extractText(e: Element): StringBuilder 
        if (e is Text) 
            val text = e as Text
            sb.append(text.text)
         else if (e is Container) 
            val container = e as Container
            for (child in container.children) 
                extractText(child)
            
         else 
            throw Exception("Unrecognized element:$e")
        
        return sb
    
    extractText(this)
    return sb.toString()

现在有一点提高，你看见哪些灰色的代码了吗？哪些是无用的。

fun Element.extractText(): String 
    val sb = StringBuilder()
    fun extractText(e: Element): StringBuilder 
        if (e is Text) 
            sb.append(e.text)
         else if (e is Container) 
            e.children.forEach(::extractText)
         else 
            throw Exception("Unrecognized element:$e")
        
        return sb
    
    extractText(this)
    return sb.toString()

我们if else 替换成when

fun Element.extractText(): String 
    val sb = StringBuilder()
    fun extractText(e: Element): StringBuilder 
        when (e) 
            is Text -> 
                sb.append(e.text)
            
            is Container -> 
                e.children.forEach(::extractText)
            
            else -> 
                throw Exception("Unrecognized element:$e")
            
        
        return sb
    
    extractText(this)
    return sb.toString()

使用密封类，把when里面的else去掉

fun Element.extractText(): String 
    val sb = StringBuilder()
    fun extractText(e: Element): StringBuilder 
        when (e) 
            is Text -> sb.append(e.text)
            is Container -> e.children.forEach(::extractText)
        
        return sb
    
    extractText(this)
    return sb.toString()

我们用Kotlin写同样逻辑，代码更少，逻辑逻辑更清晰，表现力更强。

现在，局部函数，扩展函数、顶级函数、默认参数——使用这些。
它们将使您的代码更好。

8.表达式

看一下，下面这些例子表达方式写起来就像在脑海中旧的习惯一样。我们会尝试变换让他们变得更好。

class Example(val a: Int, val b: String?, val c: Boolean)

fun main(args: Array<String>) 
    var ex = Example(1, null, true)

    val a = ex.a
    val b = ex.b
    val c = ex.c
    println("a = " + a + ", b = " + b + ", c = " + c)

    val map = HashMap<String, Int>()
    map.put("k1", 1)
    map.put("k2", 2)
    map.put("k3", 3)

    for (e in map.entries) 
        val key = e.key
        val value = e.value
        println(key + " -> " + value)
    

    var s: String
    if (System.currentTimeMillis() % 2L == 0L) 
        println("Yal!")
        s = "Luck!"
     else 
        s = "Not this time"
    
    println(s)


fun test(e: Example): String 
    when (e.a) 
        1 -> return "Odd"
        3 -> return "Odd"
        5 -> return "Odd"
        2 -> return "Even"
        4 -> return "Even"
        6 -> return "Even"
        else -> return "Too big"
    


fun test2(str: String?): String? 
    println(str!!.length)

    if (str != null) 
        str.forEach  it ->
            println(it)
        
    

    if (str == null) return null
    if (str == null) throw RuntimeException("Exception")
    if (str == null) error("error")

    return ""

第一件事这里要说的是var。我不能说永远不要使用var。var是有用的。可变变量可以用于许多事情上。但是它不是被鼓励的。如果你需要var，你需要一个很好的理由。
这里没有好的理由使用val，这是肯定的。

val ex = Example(1, null, true)

这里,让我们看看这三个。它是重复，重复是丑陋的。重复是容易出错，特别是当这不是单一的名字，但被许多事情所束缚。因此，我想要摆脱这种重复。这里我可以用with函数解决。它有个陌生的东西，这是一个建筑结构。在Kotlin中，它是一个函数。在这里，我们可以得到摆脱所有与ex有关的事情，就像这样。

with(ex)
    val a = a
    val b = b
    val c = c
    println("a = " + a + ", b = " + b + ", c = " + c)

但现在看起来是更愚蠢的,对吧？我只是在分配相同的变量。不要这样做。现在我打印了一行，字符串加某物，字符串加某物，字符串加东西。这是尴尬的。现在大多数语言都有『string interpolation』，Kotlin也有。使用字符串插值，它是很好。

with(ex)
    println("a = $a, b = $b, c = $c")

现在，我在创建了一个map。我可以把它变的好一点，通过使用我的索引操作符。

val map = HashMap<String, Int>()
map["k1"] = 1
map["k2"] = 2
map["k3"] = 3

但是我可以使用builder function让它更好一点，因次我能做的是用Pairs替代所有的key和value。

val map = mapOf(Pair("k1", 1), Pair("k2", 2), Pair("k2", 2))

是的，所以map可以由Pair去构建。而map只是一系列的由键到值组成的Pair。但实际上，Pair在这里是有点多余。所以我们通常用to function去替代。它不是一个内置操作符，只是一个库函数。这里，这就是如何你创建一个Map。

val map = mapOf("k1" to 1,"k2" to 2,"k3" to 3 )

下面关于if语句的语法，是我非常讨厌的，因为它的声明和赋值是分开的。所以我很喜欢在Kotlin这样做。所以如果这样做的，你会发现还有很多这样的事情，实际上就是用『表达式』代替『语句』。这是对于C语言家族来说很陌生。我们习惯于把声明和赋值进行分开。你把表达式赋值给变量和写语句来指定一个值。

var s: String
if (System.currentTimeMillis() % 2L == 0L) 
    println("Yal!")
    s = "Luck!"
 else 
    s = "Not this time"

println(s)

当然，这里你就不用使用一个var，你不用另外写一行，你可以在一行指定的值。因此，表达式是更好的。顺便说一下，这个表达式的结果是语句块中的最后一项。

val s = if (System.currentTimeMillis() % 2L == 0L) 
    println("Yal!")
    "Luck!"
 else 
    "Not this time"

看下这个when的例子，when不像Java的switch那样呆板固执，它是很强大的，也很重要的。你也可以这么做像这样写代码，对吧？

fun test(e: Example): String 
    when (e.a) 
        1 -> return "Odd"
        3 -> return "Odd"
        5 -> return "Odd"
        2 -> return "Even"
        4 -> return "Even"
        6 -> return "Even"
        else -> return "Too big"
    

但是这里如果只有一个返回值会更好一些，像这样

fun test(e: Example): String 
    return when (e.a) 
        1 -> "Odd"
        3 -> "Odd"
        5 -> "Odd"
        2 -> "Even"
        4 -> "Even"
        6 -> "Even"
        else -> "Too big"
    

你也不必重复这些case，你可以把他们合在一起。像这样

fun test(e: Example): String 
    return when (e.a) 
        1, 3, 5 -> "Odd"
        in setOf(2, 4, 6) -> "Even"
        else -> "Too big"
    

是的，所以这个可以进一步简化。再一次，你在努力消除干扰。

fun test(e: Example) = when (e.a) 
    1, 3, 5 -> "Odd"
    in setOf(2, 4, 6) -> "Even"
    else -> "Too big"

顺便说一下，如果你想检查奇偶数，不要像我这样做。这只是为了演示目的。

9.函数类型

让我们来看一些函数风格。

fun main() 
    val numbers = (1..100).toList()

    val list = mutableListOf<String>()
    for (it in numbers) 
        if (it % 16 == 0) 
            list.add("0x" + it.toString(16))
        
    

    println(list)

    repeat(6) 
        println(it)
    


fun repeat(times: Int, body: (Int) -> Unit) 
    for (index in 0 until times) 
        body(index)
    

所以人们经常将Kotlin称为函数式语言。事实上，我不这么认为。我认为Kotlin是一个支持函数式风格的多范式语言。

你用Kotlin不用一定要写函数风格的代码，但它通常这这样做会更好的。

fun main() 
    val list = (1..100).toList()
        .filter 
            it % 16 == 0
        .map 
            "0x" + it.toString(16)
        
    println(list)

    repeat(6) 
        println(it)
    


fun repeat(times: Int, body: (Int) -> Unit) 
    for (index in 0 until times) 
        body(index)