Kotlin系列之不知道约定，可能有些代码你看不懂_为什么查看 kotlin 的源码时,总是有奇怪的代码看不懂(6)

2401_84853048

于 2024-05-12 14:58:56 发布

阅读量340

点赞数 3

分类专栏：程序员文章标签：鸿蒙面试学习

本文链接：https://blog.csdn.net/2401_84853048/article/details/138755932

版权

程序员专栏收录该内容

106 篇文章 1 订阅

订阅专栏

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

var userId: Int,
var age:Int=0
)

val userA = People(“Coffee”,123,23)
val userB = People(“Tea”,125,24)
println("Coffee的岁数比 Tea ${if(userA > userB) “大” else “小”} ")

如果直接给两个People对象用>或者<运算符，编译器是会报错的，我们给People增加个扩展函数compareTo,让它里面对age做对比

operator fun People.compareTo(other:People) = (this.age - other.age)

这个时候编译器就不报错了，运行一下得到的结果为

Coffee的岁数比 Tea 小

注意：如果定义的扩展函数，在标准库里面已经存在同样签名的函数，那么运算符的逻辑只会以标准库的为准，自己定义的函数里面的逻辑将会无效,因为成员函数的优先级比扩展函数要高

我们以String为例，在kotlin标准库里面，String也有同样签名的compareTo函数，说明就算我们不去给String约定一个compareTo的函数，它也是可以使用>或者<这样的运算符,逻辑是逐个比较两个字符串各个字符的ASCII码值的大小，比如下面这段代码

println(“123 > 32 ${“123” > “32”}”)

如果不将对比的两个字符串转成整数类型，那么对比出的结果一定是false,因为它们对比的是两个字符串第一位1与3的大小，如果说我们给String增加一个compareTo(String)的扩展函数，让它可以实现将字符串转成整数类型在对比，会有效吗？我们试试看

operator fun String.compareTo(other:String):Int{
return this.toInt() - other.toInt()
}

依然还是false,结果就不展示出来了，有兴趣的小伙伴可以自己跑下试试，这个就说明了如果标准库里面有同样签名的函数，自己约定的函数将不起作用，逻辑以优先级高的为准，而且我们也不用每次定义函数时候都去标准库里面找找到底有没有相同签名的函数，因为如果有，编译器会提示你这个函数在标准库里面已经存在相同签名的了，比如上面这个compareTo,其实它是有个警告的

说明这个扩展函数被成员函数给隐藏了

get与set的约定

kotlin里面对集合进行赋值或者获取一个值的时候，往往是通过list[index]这种方式来操作的，其实这个也就是集合类里面对get与set函数做了约定

而我们可以利用这种约定，用在其他场景上，比如一个接口的数据类有若干个字断，分别运用在业务场景的各个角落，而如果有一天服务端同学告诉你要更改某一个字断，我们是不是要连着去改所有业务场景中用过这个字断的地方，有的字断用的少还好，有的字断用的地方多可能一改就要改半天，这个时候我们可以尝试着在数据类里面约定个get函数(其实这种场景应该是用Gson里面的@SerializedName，这里就是对约定举个例子～)，传进去的下标值就是访问属性的位置，这样应用层只需要访问下标值就可以了，不用去关心具体字断是什么，我们现在给People类增加一个get函数

data class People(var nickName: String, var userId: Int,var age:Int=0) {

operator fun get(index:Int):Any?{
if(index == 0){
return nickName
}else if(index == 1){
return userId
}else{
return age
}
}

operator fun set(index:Int,value:Any?){
if(index == 0){
nickName = value as String
}else if(index == 1){
userId = value as Int
}else{
age = value as Int
}
}
}

我们现在通过下标去访问一个People类的属性，并通过下标去改变一个People的属性

val people = People(“Tony”,12,30)
println(“name = ${people[0]},userid = ${people[1]},age = ${people[2]}”)
…
name = Tony,userid = 12,age = 30

people[0] = “Peter”
people[1] = 20
people[2] = 23
println(“name = ${people[0]},userid = ${people[1]},age = ${people[2]}”)
…
name = Peter,userid = 20,age = 23

in与rangTo的约定

这两个约定我觉得放在一起说比较好，因为in表示判断是否在某一个区间里面，而rangeTo表示的是某一个区间，经常放在一起使用，比如我们在用到for循环的时候，遍历1到10这十个数字并打印出来，我们会这样做

for(i in 1…10){
println(i)
}
…
1
2
3
4
5
6
7
8
9
10

除此之外，我们还可以用in和rangeTo来判断某个日期在不在一个时间段里面

val date = LocalDate.now()
val anotherDate = LocalDate.of(2022, 12, 12)
val startDate = LocalDate.of(2022, 12, 22)
val endDate = LocalDate.of(2023, 2, 22)
println(“$date ${if (date in startDate..endDate) "在" else "不在"}范围里面") println("$ anotherDate ${if (anotherDate in startDate…endDate) “在” else “不在”}范围里面”)
…
2023-01-29 在范围里面
2022-12-12 不在范围里面

解构声明

对于一些属性比较多的数据类，如果想要单独把这些属性拿出来放在一个变量里面，可能需要写好几行赋值语句，比如People类，现在要生成一个名字叫Tony,年龄30岁，用户ID是10的对象,然后再用三个变量保存People的三个属性，代码如下

val people = People(“Tony”,10,30)
val name = people.nickName
val userId = people.userId
val age = people.age

如果属性多一些，赋值语句就更多了，kotlin里面有更简洁的作法

val (x,y,z) = People(“Tony”,10,30)
println(“name = $x id = $y age = $z”)
…
name = Tony id = 10 age = 30

一行代码就完成了生成对象以及给三个变量赋值的操作，这个在kotlin里面就叫做解构声明，将一个单独的有多个属性值的对象拆分开来，给多个变量进行赋值，这其中也用到了约定，像上面的代码其实编译器自动给People加上了componentN()的方法，N就是属性的位置，所以像上面的代码，编译器的眼里其实是这样的

val people = People(“Tony”,10,30)
val x = people.component1()
val y = people.component2()
val z = people.component3()
println(“name = $x id = $y age = $z”)

我们也可以为非数据类手动加上componentN()方法，让它可以使用解构声明，比如现在有一个学生类

class Student(var name:String,var score:Int,var schoolName:String)

如果什么都不做，直接使用解构声明语法，编译器是会报错的

我们现在给Student类加上componentN方法

class Student(var name:String,var score:Int,var schoolName:String) {
operator fun component1() = name
operator fun component2() = score
operator fun component3() = schoolName
}

现在可以给Student类使用解构声明语法了

val (x,y,z) = Student(“Li”,90,“qinghuadaxue”)
println(“name = $x score = $y schoolName = $z”)
…
name = Li score = 90 schoolName = qinghuadaxue

invoke约定

最后一个约定，也是我觉得在kotlin里面用途最广的一个约定，因为它与lambda表达式有关，我们先从简单的开始说起，首先在kotlin里面规定了，如果一个类里面定义了一个invoke的约定函数，那么这个函数可以直接用类名代替invoke去调用，我们还是用代码直观的来看下

data class People(var nickName: String, var userId: Int=0,var age:Int=0) {
operator fun invoke(address:String?){
println(“ ${nickName}住在$ address”)
}
}

还是在People里面，我们定义了一个约定函数invoke，传入一个String,并且直接输入一段话，这个时候我们在应用层除了可以直接用People对象调用invoke函数输入这段话以外，我们还可以这样做

People(“天才威”)(“狗熊岭”)

直接把整个类名加上构造函数代替了invoke执行了整个函数，这种做法是不是很眼熟，我们在调用一个lambda表达式的时候也是这么做的，我们知道一个lambda表达式本身是不会执行的，如果想要执行一个lambda表达式里面的函数体，必需在后面加上一对(),现在我们来看下这样做的原因

fun bear(message: () -> Unit) {
message()
}

我们先定义了一个高阶函数bear，函数接收一个函数类型的参数message,message就是一个lambda表达式，我们在bear函数体里面直接加上()调用message,到这里，我们反编译下这段代码，看下java代码

public final void bear(@NotNull Function0 message) {
Intrinsics.checkNotNullParameter(message, “message”);
message.invoke();
}

熟悉高阶函数的都知道，一个非内联的高阶函数，它接收的lambda表达式的参数其实就是一个匿名类，在java代码中，Function0就是匿名类，我们去Function0里面看看

public interface Function0 : Function {
/** Invokes the function. */
public operator fun invoke(): R
}

可以看到Function0就是一个接口，里面只有一个invoke函数，并且用operator操作符修饰，所以真实调用的时候我们可以直接以Function0()这种形式调用，如果有参数，直接在()中加上参数即可

总结

约定的内容都讲完了，相信有部分约定其实在实际开发当中我们已经在用了，有的我们可能用的还很少，但是值得肯定的是，熟练掌握了约定，我们写代码的效率，或者是代码本身的可读性方面，都会有很大的提升～

链接：https://juejin.cn/post/7196808785976426552
作者：Coffeeee

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。
在这里插入图片描述
相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。