Kotlin扩展函数及实现机制的深入探索

2023-09-11 20:06:05 121

前言

2017年GoogleIO大会宣布使用Kotlin作为Android的官方开发语言，相比较与典型的面相对象的JAVA语言，Kotlin作为一种新式的函数式编程语言，也有人称之为Android平台的Swift语言。

先让我们看下实现同样的功能，Java和Kotiln的对比：

//JAVA，20多行代码，充斥着findViewById，类型转换，匿名内部类这样的无意义代码

publicclassMainJavaActivityextendsActivity{
@Override
publicvoidonCreate(@NullableBundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

TextViewlabel=(TextView)findViewById(R.id.label);
Buttonbtn=(Button)findViewById(R.id.btn);

label.setText("hello");
label.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Log.d("Glen","onClickTextView");
}
});
btn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Log.d("Glen","onClickButton");
}
});
}
}

再来看Kotlin

//Kotlin,没有了冗余的findViewById，我们可以直接对资源id进行操作，也不需要匿名内部类的声明，更关注函数的实现本身，抛弃了复杂的格式
classMainKotlinActivity:Activity(){

overridefunonCreate(savedInstanceState:Bundle?){
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

R.id.label.setText("hello")
R.id.label.onClick{Log.d("Glen","onClickTextView")}
R.id.btn.onClick{Log.d("Glen","onClickButton")}
}
}

实现这些需要借助Kotlin的扩展函数与高阶函数，本文主要介绍一下扩展函数。

什么是扩展函数？

扩展函数数是指在一个类上增加一种新的行为，甚至我们没有这个类代码的访问权限。这是一个在缺少有用函数的类上扩展的方法，Kotlin能够为我们做到那些令人关注的事情，而这些Java做不到。

在Java中，通常会实现很多带有static方法的工具类，而Kotlin中扩展函数的一个优势是我们不需要在调用方法的时候把整个对象当作参数传入，它表现得就像是属于这个类的一样，而且我们可以使用this关键字和调用所有public方法。

1.Kotlin扩展函数与扩展属性(KotlinExtensions)

Kotlin能够扩展一个类的新功能而无需继承该类，或者对任意的类使用像“装饰者(Decorator)”这样的设计模式。这些都是通过叫做“扩展(extensions)”的特殊声明实现的。Kotlin扩展声明既支持扩展函数也支持扩展属性，本文主要讨论扩展函数，至于扩展属性实现的机制类似。

扩展函数的声明非常简单，他的关键字是.，此外我们需要一个“接受者类型(recieviertype)”来作为他的前缀。以类MutableList为例，现在为它扩展一个swap方法，如下：

funMutableList.swap(index1:Int,index2:Int){
valtmp=this[index1]
this[index1]=this[index2]
this[index2]=tmp
}

MutableList是kotlin提供的基础库collection中的List容器类，这里在声明里作为“接受者类型”，.作为声明关键字，swap是扩展函数名，其余和Kotlin声明一个普通函数并无区别。

额外提一句，Kotlin的this语法要比JAVA更灵活，这里扩展函数体里的this代表的是接受者类型对象。

如果我们想要调用这个扩展函数，可以这样：

funuse(){
vallist=mutableListOf(1,2,3)
list.swap(1,2)
}

2.Kotlin扩展函数是怎么实现的

扩展函数的调用看起来就像是原生方法一样自然，使用起来也非常顺手，但是这样的方法会不会带来性能方面的掣肘呢？有必要探究一下Kotlin是如何实现扩展函数的，直接分析Kotlin源码难度还是挺大，还好AndroidStudio提供了一些工具，我们可以通过KotlinByteCode指令，查看Kotlin语言转换的字节码文件，仍以MutableList,swap为例，转换为字节码之后的文件如下：

//================com/example/glensun/demo/extension/MutableListDemoKt.class=================
//classversion50.0(50)
//accessflags0x31

publicfinalclasscom/example/glensun/demo/extension/MutableListDemoKt{

//accessflags0x19
//signature(Ljava/util/List;II)V
//declaration:voidswap(java.util.List,int,int)
publicfinalstaticswap(Ljava/util/List;II)V
@Lorg/jetbrains/annotations/NotNull;()//invisible,parameter0
L0
ALOAD0
LDC"$receiver"
INVOKESTATICkotlin/jvm/internal/Intrinsics.checkParameterIsNotNull(Ljava/lang/Object;Ljava/lang/String;)V
L1
LINENUMBER8L1
ALOAD0
ILOAD1
INVOKEINTERFACEjava/util/List.get(I)Ljava/lang/Object;
CHECKCASTjava/lang/Number
INVOKEVIRTUALjava/lang/Number.intValue()I
ISTORE3
L2
LINENUMBER9L2
ALOAD0
ILOAD1
ALOAD0
ILOAD2
INVOKEINTERFACEjava/util/List.get(I)Ljava/lang/Object;
INVOKEINTERFACEjava/util/List.set(ILjava/lang/Object;)Ljava/lang/Object;
POP
L3
LINENUMBER10L3
ALOAD0
ILOAD2
ILOAD3
INVOKESTATICjava/lang/Integer.valueOf(I)Ljava/lang/Integer;
INVOKEINTERFACEjava/util/List.set(ILjava/lang/Object;)Ljava/lang/Object;
POP
L4
LINENUMBER11L4
RETURN
L5
LOCALVARIABLEtmpIL2L53
LOCALVARIABLE$receiverLjava/util/List;L0L50
LOCALVARIABLEindex1IL0L51
LOCALVARIABLEindex2IL0L52
MAXSTACK=4
MAXLOCALS=4

@Lkotlin/Metadata;(mv={1,1,7},bv={1,0,2},k=2,d1={"\u0000\u0012\n\u0000\n\u0002\u0010\u0002\n\u0002\u0010!\n\u0002\u0010\u0008\n\u0002\u0008\u0003\u001a\u0010\u0000\u001a\u00020\u0001*\u0008\u0012\u0004\u0012\u00020\u00030\u00022\u0006\u0010\u0004\u001a\u00020\u00032\u0006\u0010\u0005\u001a\u00020\u0003\u00a8\u0006\u0006"},d2={"swap","","","","index1","index2","productionsourcesformoduleapp"})
//compiledfrom:MutableListDemo.kt

}
//================META-INF/productionsourcesformoduleapp.kotlin_module=================

这里的字节码已经相当直观，更令人惊喜的是AndroidStudio还具备将字节码转为JAVA文件的能力，点击上面的Decompile按钮，可以得到如下JAVA代码：

importjava.util.List;
importkotlin.Metadata;
importkotlin.jvm.internal.Intrinsics;
importorg.jetbrains.annotations.NotNull;
@Metadata(
mv={1,1,7},
bv={1,0,2},
k=2,
d1={"\u0000\u0012\n\u0000\n\u0002\u0010\u0002\n\u0002\u0010!\n\u0002\u0010\b\n\u0002\b\u0003\u001a\u0010\u0000\u001a\u00020\u0001*\b\u0012\u0004\u0012\u00020\u00030\u00022\u0006\u0010\u0004\u001a\u00020\u00032\u0006\u0010\u0005\u001a\u00020\u0003¨\u0006\u0006"},
d2={"swap","","","","index1","index2","productionsourcesformoduleapp"}
)

publicfinalclassMutableListDemoKt{
publicstaticfinalvoidswap(@NotNullList$receiver,intindex1,intindex2){
Intrinsics.checkParameterIsNotNull($receiver,"$receiver");
inttmp=((Number)$receiver.get(index1)).intValue();
$receiver.set(index1,$receiver.get(index2));
$receiver.set(index2,Integer.valueOf(tmp));
}
}

从得到的JAVA文件分析，扩展函数的实现非常简单，它没有修改接受者类型的成员，仅仅是通过静态方法来实现的。这样，我们虽然不必担心扩展函数会带来额外的性能消耗，但是它也不会带来性能上的优化。

3.更复杂的情况

下面来讨论一些更特殊的情况。

3.1当发生继承时，扩展函数由于本质上是静态方法，它会严格按照参数类型去执行调用，而不会去优先执行或者主动执行父类的方法，如下的例子所示：

openclassA
classB:A()
funA.foo()="a"
funB.foo()="b"
funprintFoo(a:A){
println(a.foo())
}
println(B())

上述例子的输出结果是a，因为扩展函数的入参类型是A，他将会严格按照入参类型执行函数调用。

3.2如果扩展函数和现有的类成员发生冲突，kotlin将会默认使用类成员，这一步选择是在编译期处理的，生成的字节码是将会是调用类成员的方法，如下例子：

classC{
funfoo(){println("Member")}
}
funC.foo(){println("Extension")}
println(C().foo())

上述的例子将会输出Member。Kotlin不允许扩展一个已有的成员，原因也很好理解，我们不希望扩展函数成为调用三方sdk的漏洞，不过如果你试图使用重载的方式创建扩展函数，这样是可行的。

3.3Kotlin严格区分了可能为空和不为空的入参类型，同样也应用在扩展函数的中，为了声明一个可能为空的接受者类型，可以参考如下例子：

funMutableList?.swap(index1:Int,index2:Int){
if(this==null){
println(null)
return
}

valtmp=this[index1]
this[index1]=this[index2]
this[index2]=tmp
}

3.4我们有时候还希望能够添加类似JAVA的“静态函数”的扩展函数，这时需要借助“伴随对象(CompanionObject)”来实现，如下这个例子：

classD{
companionobject{
valm=1
}
}

funD.Companion.foo(){
println("$minextension")
}

D.foo()

上面的例子会输出1inextension，注意这里调用foo这个扩展函数时，并不需要类D的实例，类似于JAVA的静态方法。

3.5如果留意前面的例子，我们会发现kotlin的this语法和JAVA不同，使用范围更灵活，仅以扩展函数为例，当在扩展函数里调用this时，指代的是接受者类型的实例，那么如果这个扩展函数声明在一个类内部，我们如何通过this获取到类的实例呢？可以参考下面的例子：

classE{
funfoo(){
println("fooinClassE")
}

}
classF{
funfoo(){
println("fooinClassF")
}

funE.foo2(){
this.foo()
this@F.foo()
}
}

E().foo2()

这里使用了kotlin的this指定语法，关键字是@,后接指定的类型，上述例子的输出结果是

fooinClassE
fooinClassF

4.扩展函数的作用域

一般来说，我们习惯将扩展函数直接定义在包内，例如：

packagecom.example.extension
funMutableList.swap(index1:Int,index2:Int){
valtmp=this[index1]
this[index1]=this[index2]
this[index2]=tmp
}

这样，在同一个包内可以直接调用改扩展函数，如果我们需要跨包调用扩展函数，我们需要通过import来指明，以上述的例子为例，可以通过importcom.example.extension.swap来指定这个扩展函数，也可以通过importcom.example.extension.*表示引入该包内的所有扩展函数。得益于AndroidStudio具备的自动联想能力，通常不需要我们主动输入import指令。

有时候，我们也会把扩展函数定义在类的内部，例如：

classG{
funInt.foo(){
println("fooinClassG")
}
}

这里的Int.foo()是一个定义在类G内部的扩展函数，在这个扩展函数里，我们直接使用Int类型作为接受者类型，因为我们将扩展函数定义在了类的内部，即使我们设置访问权限为public，它也只能在该类或者该类的子类中被访问，如果我们设置访问权限为private，那么在子类中也不能访问这个扩展函数。

5.扩展函数的实际应用

5.1Utils工具类

在JAVA中，我们习惯将工具类命名成*Utils，例如FileUtils,StringUtils等等，著名的java.util.Collections也是这么实现的。调用这些方法的时候，总觉得这些类名碍手碍脚的，例如这样：

//Java
Collections.swap(list,Collections.binarySearch(list,Collections.max(otherList)),Collections.max(list));
Collections.max(list));

通过静态引用，能让情况看起来好一点，例如这样：

//Java
swap(list,binarySearch(list,max(otherList)),max(list));

但是这样既没有IDE的自动联想提示，方法调用的主体也显得不明确。如果能做成下面这样就好了：

//Java
list.swap(list.binarySearch(otherList.max()),list.max());

但是list是JAVA默认的基础类，在JAVA语言里，如果不使用继承，肯定是没法做到这样的，而在Kotlin中就可以借助扩展函数来实现啦。

5.2AndroidView胶水代码

回到最开始的例子，对于Android开发来说，对findViewById()这个方法一定不会陌生，为了获取一个View对象，我们总得先调用findViewById()然后再执行类型转换，这样无意义的胶水代码让Activity或者Fragment显得臃肿无比，例如：

//JAVA

publicclassMainJavaActivityextendsActivity{
@Override
publicvoidonCreate(@NullableBundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

TextViewlabel=(TextView)findViewById(R.id.label);
Buttonbtn=(Button)findViewById(R.id.btn);

label.setText("hello");
label.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Log.d("Glen","onClickTextView");
}
});
btn.setOnClickListener(newView.OnClickListener(){
@Override
publicvoidonClick(Viewv){
Log.d("Glen","onClickButton");
}
});
}
}

我们考虑利用扩展函数结合泛型，避免频繁的类型转换，扩展函数定义如下：

//kotlin
funActivity.find(@IdResid:Int):T{
returnfindViewById(id)asT
}

调用的时候，如下：

//Kotlin
...
TextViewlabel=find(R.id.label);
Buttonbtn=find(R.id.btn);
...

只是我们还是需要获取到label,btn，这样无意义的中间变量，如果在Int类上扩展，可以直接对R.id.*操作，这样更直接，再结合高阶函数，函数定义如下：

//Kotlin
funInt.setText(str:String){
vallabel=find(this).apply{
text=str
}
}

funInt.onClick(click:()->Unit){
valtmp=find(this).apply{
setOnClickListener{
click()
}
}
}

我们就可以这样调用：

//Kotlin
R.id.label.setText("hello")
R.id.label.onClick{Log.d("Glen","onClickTextView")}
R.id.btn.onClick{Log.d("Glen","onClickButton")}

通常这些扩展函数可以放到基类中，根据扩展函数的作用域知识，我们可以在所有子类中都调用到这些方法，所以kotlin的Activity可以写成：

//Kotlin
classMainKotlinActivity:KotlinBaseActivity(){
overridefunonCreate(savedInstanceState:Bundle?){
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

R.id.label.setText("hello")
R.id.label.onClick{Log.d("Glen","onClickTextView")}
R.id.btn.onClick{Log.d("Glen","onClickButton")}
}
}

从原来JAVA冗余的20多行代码，精简到只需要3行代码，而且代码可读性更高，更加直观，这便是函数式编程语言Kotlin的强大威力。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。

Kotlin扩展函数及实现机制的深入探索

热门推荐

随机推荐