怎么样编写地道的Kotlin代码

Posted ihrthk

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了怎么样编写地道的Kotlin代码相关的知识,希望对你有一定的参考价值。

怎么样编写地道的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)
    

以上是关于怎么样编写地道的Kotlin代码的主要内容,如果未能解决你的问题,请参考以下文章

怎么样编写地道的Kotlin代码

怎么样编写地道的Kotlin代码

怎么样编写地道的Kotlin代码

如何在片段 kotlin 中编写 onBackPressed()

如何从片段 KOTLIN 中调用意图 [重复]

Kotlin学习之旅解决错误:kotlin.NotImplementedError: An operation is not implemented: Not yet implemented(代码片段