Kotlin学习教程之操作符重载详解

2023-09-16 21:58:06 49

前言

在Kotlin中，我们可以用约定的操作符，代替调用代码中以特定的命名定义的函数，来实现与之对应的操作。例如在类中定义了一个名为plus的特殊方法，就可以使用加法运算符+代替plus()的方法调用。由于你无法修改已有的接口定义，因此一般可以通过扩展函数来为现有的类增添新的约定方法，从而使得操作符重载这一语法糖适应任何现有的Java类。

算术运算符

我们就从最简单直接的例子+这一类算术运算符开始。

dataclassPoint(valx:Int,valy:Int){
operatorfunplus(other:Point)=Point(x+other.x,y+other.y)
operatorfunplus(value:Int)="toString:${Point(x+value,y+value)}"
}

funmain(args:Array){
valp1=Point(1,2)
valp2=Point(3,4)
println(p1+p2)
println(p1+3)
}

/*
Point(x=4,y=6)
toString:Point(x=4,y=5)
*/

operator修饰符是必须的，否则plus只是一个普通方法，不能通过+调用。
操作符是有优先级的，比较*优先级高于+，不论这个操作符应用于什么对象，这种优先级都是固定存在的。
plus方法的参数类型是任意的，因此可以方法重载，但是参数数量只能是1，因为+是一个二元操作符。plus方法的返回值类型也是任意的。
如果出现多个方法签名相同的operator扩展方法，根据import决定使用哪个一，例如：

//第一个文件：
packagepackage0
operatorfunPoint.times(value:Int)=Point(x*value,y*value)
//第二个文件：
packagepackage1
operatorfunPoint.times(value:Int)=Unit//Donothing.
//使用第一个扩展操作符：
importpackage0.times
valnewPoint=Point(1,2)*3

Kotlin为一些基本类型预定义了一些操作符方法，我们平时常写的基本数据计算也可以翻译成调用这些操作符方法，比如(2+3)*4可以翻译成2.plus(3).times(4)，2+3*4可以翻译成2.plus(3.times(4))。根据扩展函数的语法，扩展函数无法覆盖与类已有的方法签名相同的方法，因此，不必担心随随便便给Int自定义一个plus扩展方法就能让1+1变得不等于2。

同时，所有操作符都针对基本类型做了优化，比如1+2*3、4<5，不会为它们引入函数调用的开销。

所有可重载的算术运算符有：

表达式	翻译为
a+b	a.plus(b)
a-b	a.minus(b)
a*b	a.times(b)
a/b	a.div(b)
a%b	a.rem(b)、 a.mod(b) （在Kotlin1.1中被弃用）
a..b	a.rangeTo(b)

它们的优先级与普通的数字类型运算符优先级相同。其中rangeTo会在下面说明。

广义赋值操作符

表达式	翻译为
a+=b	a.plusAssign(b)
a-=b	a.minusAssign(b)
a*=b	a.timesAssign(b)
a/=b	a.divAssign(b)
a%=b	a.remAssign(b)、 ~~a.modAssign(b)~~ （在Kotlin1.1中被弃用）

对于以上广义赋值操作符：

如果对应的二元算术运算符函数也可用，则报错。plus对应plusAssign。minus、times等也类似。
返回值类型必须为Unit。
如果执行a+=b时plusAssign不存在，会尝试生成a=a+b，其中的a+b使用的就是plus操作符方法，相当于调用a=a.plus(b)。并且此时会要求a+b的plus方法的返回值类型必须与a类型一致（如果单独使用a+b不做此要求）。

dataclassSize(varwidth:Int=0,varheight:Int=0){
operatorfunplus(other:Size):Size{
returnSize(width+other.width,height+other.height)
}
operatorfunplusAssign(other:Size){
width+=other.width
height+=other.height
}
}

funmain(args:Array){
//vars1=Size(1,2)//如果这么写，执行+=时会报错.
vals1=Size(1,2)
vals2=Size(3,4)
s1+=s2
}

我们使用这个例子来理解：为什么使用var定义的s1会导致+=报错呢？因为理论上，执行+=时，既可以调用s1=s1+s2，也就是s1=s1.plus(s2)，又可以调用s1.plusAssign(s2)，都符合操作符重载约定，这样就会产生歧义，而如果使用val定义s1，则只可能执行s1.plusAssign(s2)，因为s1不可被重新赋值，因此s1=s1+s2这样的语法是出错的，永远不能能调用，那么调用s1+=s2就不会产生歧义了。

既然编译器会帮我把a+=b解释成a=a+b，那是不是意味着我只需要plus永远不需要plusAssign了呢？比较好的实践方式是：

+(plus)始终返回一个新的对象
+=(plusAssign)用于内容可变的类型，修改自身的内容。

Kotlin标准库中就是这么实现的：

funmain(args:Array){
vallist=arrayListOf(1,2)
list+=3//添加元素到自身集合,没有新的对象被创建,调用的是add方法.
valnewList=list+4//创建一个新的ArrayList,添加自身元素和新元素并返回新的ArrayList.
}

表达式	翻译为
ainb	b.contains(a)
a!inb	!b.contains(a)

println("hello"inarrayListOf("hello",",","world"))
/*
true
*/

在for循环中使用in操作符会执行迭代操作，for(xinlist){/*遍历*/}将被转换成list.iterator()的调用，然后在上面重复调用hasNext和next方法。

rangeTo

rangeTo用于创建一个区间。例如1..10也就是1.rangeTo(10)代表了从1到10这10个数字，Int.rangeTo方法返回一个IntRange对象，IntRange类定义如下：

/**
*Arangeofvaluesoftype`Int`.
*/
publicclassIntRange(start:Int,endInclusive:Int):IntProgression(start,endInclusive,1),ClosedRange{
overridevalstart:Intget()=first
overridevalendInclusive:Intget()=last
overridefuncontains(value:Int):Boolean=first<=value&&value<=last
overridefunisEmpty():Boolean=first>last
overridefunequals(other:Any?):Boolean=
otherisIntRange&&(isEmpty()&&other.isEmpty()||
first==other.first&&last==other.last)
overridefunhashCode():Int=
if(isEmpty())-1else(31*first+last)
overridefuntoString():String="$first..$last"
companionobject{
/**AnemptyrangeofvaluesoftypeInt.*/
publicvalEMPTY:IntRange=IntRange(1,0)
}
}

它的基类IntProgression实现了Iterable接口，因此1..10可以用来迭代：

for(indexin1..10){
//遍历1到10,包括1和10.
}

IntRange还实现了接口ClosedRange，可以用来判断某元素是否属于该区间。

Kotlin为Comparable定义了扩展函数rangeTo：

/**
*Createsarangefromthis[Comparable]valuetothespecified[that]value.
*
*Thisvalueneedstobesmallerthan[that]value,otherwisethereturnedrangewillbeempty.
*@samplesamples.ranges.Ranges.rangeFromComparable
*/
publicoperatorfun>T.rangeTo(that:T):ClosedRange=ComparableRange(this,that)

因此所有的Comparable对象都可以使用..区间操作符，例如：

funmain(args:Array){
valc1=Calendar.getInstance()//代表今天.
valc2=Calendar.getInstance()
c2.add(Calendar.DATE,10)//代表10天后.
valc3=Calendar.getInstance()
c3.add(Calendar.DATE,3)//代表3天后.
valc4=Calendar.getInstance()
c4.add(Calendar.DATE,13)//代表13天后.

//判断某日期是否在某两个日期范围内.
println(c3inc1..c2)
println(c4inc1..c2)
}
/*
true
false
*/

一元前缀操作符

表达式	翻译为
+a	a.unaryPlus()
-a	a.unaryMinus()
!a	a.not()

dataclassPoint(valx:Int,valy:Int)
operatorfunPoint.unaryMinus()=Point(-x,-y)
valpoint=Point(10,20)
println(-point)
/*
Point(x=-10,y=-20)
*/

递增与递减

表达式	翻译为
a++	a.inc()
a–	a.dec()

编译器自动支持与普通数字类型的前缀、后缀自增运算符相同的语义。例如后缀运算会先返回变量的值，然后才执行++操作。

索引访问操作符

表达式	翻译为
a[i]	a.get(i)
a[i,j]	a.get(i,j)
a[i_1,……,i_n]	a.get(i_1,……,i_n)
a[i]=b	a.set(i,b)
a[i,j]=b	a.set(i,j,b)
a[i_1,……,i_n]=b	a.set(i_1,……,i_n,b)

@Suppress("IMPLICIT_CAST_TO_ANY","UNCHECKED_CAST")
operatorfunSharedPreferences.get(key:String,defValue:T)=when(defValue){
isString->getString(key,defValue)
isInt->getInt(key,defValue)
isLong->getLong(key,defValue)
isFloat->getFloat(key,defValue)
isBoolean->getBoolean(key,defValue)
else->throwRuntimeException()
}asT

@SuppressLint("CommitPrefEdits")
operatorfunSharedPreferences.set(key:String,value:T)=with(edit()){
when(value){
isString->putString(key,value)
isInt->putInt(key,value)
isLong->putLong(key,value)
isFloat->putFloat(key,value)
isBoolean->putBoolean(key,value)
else->throwRuntimeException()
}.apply()
}

funmain(args:Array){
valversion=sp["key_version",47]//读sp.
sp["key_version"]=48//写sp.
}

调用操作符

表达式	翻译为
a()	a.invoke()
a(i)	a.invoke(i)
a(i,j)	a.invoke(i,j)
a(i_1,……,i_n)	a.invoke(i_1,……,i_n)

相等与不等操作符

表达式	翻译为
a==b	a?.equals(b)?:(b===null)
a!=b	!(a?.equals(b)?:(b===null))

这在Any中被定义。Java的a.equals(b)相当于Koltin的a==b，Java的a==b相当于Kotlin的a===b（同一性检查）。要自定义==操作符其实就是覆写equals方法。Kotlin中===不可被重载。

比较操作符

表达式	翻译为
a>b	a.compareTo(b)>0
a	a.compareTo(b)<0
a>=b	a.compareTo(b)>=0
a<=b	a.compareTo(b)<=0

要求compareTo返回值类型必须为Int，这与Comparable接口保持一致。

dataclassMovie(valname:String,valscore:Int,valdate:Date,valother:Any=Any()):Comparable{
overridefuncompareTo(other:Movie):Int{
returncompareValuesBy(this,other,Movie::score,Movie::date,Movie::name)//如果将Movie::other也用作比较会报错,因为other不是Comparable类型的。
}
}

funmain(args:Array){
valdf=SimpleDateFormat("yyyy-MM-dd",Locale.getDefault())
valmovie0=Movie("马戏之王",8,df.parse("2018-01-31"))
valmovie1=Movie("神秘巨星",7,df.parse("2018-01-01"))
valmovie2=Movie("移动迷宫",7,df.parse("2018-01-02"))
println(movie0
其中的compareValuesBy方法如下：
/**
*Comparestwovaluesusingthespecifiedfunctions[selectors]tocalculatetheresultofthecomparison.
*Thefunctionsarecalledsequentially,receivethegivenvalues[a]and[b]andreturn[Comparable]
*objects.Assoonasthe[Comparable]instancesreturnedbyafunctionfor[a]and[b]valuesdonot
*compareasequal,theresultofthatcomparisonisreturned.
*
*@samplesamples.comparisons.Comparisons.compareValuesByWithSelectors
*/
publicfuncompareValuesBy(a:T,b:T,varargselectors:(T)->Comparable<*>?):Int{
require(selectors.size>0)
returncompareValuesByImpl(a,b,selectors)
}

privatefuncompareValuesByImpl(a:T,b:T,selectors:ArrayComparable<*>?>):Int{
for(fninselectors){
valv1=fn(a)
valv2=fn(b)
valdiff=compareValues(v1,v2)
if(diff!=0)returndiff
}
return0
}
我们定义一个Movie类，它实现了Comparable接口，在比较时，希望按照评分、上映日期、电影名称的优先级顺序排序。可以简单的使用比较操作符对Movie对象进行“大小比较”。
操作符函数与Java


Java中调用Kotlin中的操作符方法，就跟调用普通方法一样，你不能期望在Java中写newPoint(1,2)+newPoint(3,4)这样的语法，只能乖乖调用newPoint(1,2).plus(newPoint(3,4))。


反之，Kotlin中调用Java代码却可以同Kotlin中自定义操作符方法一样方便。只要一个类提供了满足操作符方法签名的方法，哪怕它只是一个普通方法，不需要加operator修饰符（Java中也没有这个修饰符），就可以在Kotlin中以操作符的方式调用。例如：arrayList[0]相当于Java中arrayList.get(0)，尽管这个get方法是Java中定义的。又比如所有实现了Comparable的类实例都可以使用比较操作符>、<等进行比较。


Java中的位运算符在Kotlin中是没有的，它们只能使用普通方法加中缀表达式使用，只能用于Int和Long，对应关系如下：






Java中 
Kotlin中




« 有符号左移
shl(bits)


»有符号右移
shr(bits)


»>无符号右移
ushr(bits)


&与
and(bits)


|或
or(bits)


^异或
xor(bits)


!非
inv()




操作符重载与属性委托、中缀调用


我们在使用委托属性时也用过operator修饰符：
classDelegate{
operatorfungetValue(thisRef:Any?,property:KProperty<*>):String{
//...
}
operatorfunsetValue(thisRef:Any?,property:KProperty<*>,value:String){
//...
}
}
符合这样方法签名的getValue、setValue也是操作符函数，用于委托属性的getter和setter。
可以看出，操作符重载并不是一定要用如*、+、<这样的符号来表示的，比如之前的in操作符，这里的getter、setter。
除了以上这些标准的可被重载的操作符外，我们也可以通过中缀函数的调用来模拟自定义中缀操作符，实现形如ainlist这样的语法。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对毛票票的支持。

Java中	Kotlin中
« 有符号左移	shl(bits)
»有符号右移	shr(bits)
»>无符号右移	ushr(bits)
&与	and(bits)
\|或	or(bits)
^异或	xor(bits)
!非	inv()

Kotlin学习教程之操作符重载详解

热门推荐

随机推荐