我们知道,任何一门编程语言都会有一些自己专用的关键字、符号以及规定的语法规则等等。程序员们使用这些基础词汇和语法规则来表达算法步骤,也就是写代码的过程。词法分析是编译器对源码进行编译的基础步骤之一。词法分析是将源程序读入的字符序列,按照一定的规则转换成词法单元(Token)序列的过程。词法单元是语言中具有独立意义的最小单元,包括修饰符、关键字、常数、运算符、边界符等等。
3.7.1 修饰符
在Kotlin源码工程中的kotlin/grammar/src/modifiers.grm文件中,描述了Kotlin语言的修饰符,我们在此作简要注释说明:
/**
## Modifiers
*/
modifiers
: (modifier | annotations)*
;
typeModifiers
: (suspendModifier | annotations)*
;
modifier
: classModifier
: accessModifier
: varianceAnnotation
: memberModifier
: parameterModifier
: typeParameterModifier
: functionModifier
: propertyModifier
;
classModifier 类修饰符
: "abstract" 抽象类
: "final" 不可被继承final类
: "enum" 枚举类
: "open" 可继承open类
: "annotation" 注解类
: "sealed" 密封类
: "data" 数据类
;
memberModifier
: "override" 重写函数
: "open" 可被重写
: "final" 不可被重写
: "abstract" 抽象函数
: "lateinit" 后期初始化
;
accessModifier 访问权限控制, 默认是public
: "private"
: "protected"
: "public"
: "internal" 整个模块内(模块(module)是指一起编译的一组 Kotlin 源代码文件: 例如,一个 IntelliJ IDEA 模块,一个 Maven 工程, 或 Gradle 工程,通过 Ant 任务的一次调用编译的一组文件等)可访问
;
varianceAnnotation 泛型可变性
: "in"
: "out"
;
parameterModifier
: "noinline"
: "crossinline"
: "vararg" 变长参数
;
typeParameterModifier
: "reified"
;
functionModifier
: "tailrec" 尾递归
: "operator"
: "infix"
: "inline"
: "external"
: suspendModifier
;
propertyModifier
: "const"
;
suspendModifier
: "suspend"
;
这些修饰符的完整定义,在kotlin/compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java源码中:
KtModifierKeywordToken[] MODIFIER_KEYWORDS_ARRAY =
new KtModifierKeywordToken[] {
ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD, OVERRIDE_KEYWORD, PRIVATE_KEYWORD,
PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD,
REIFIED_KEYWORD, COMPANION_KEYWORD, SEALED_KEYWORD, LATEINIT_KEYWORD,
DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD,
CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD, SUSPEND_KEYWORD, HEADER_KEYWORD, IMPL_KEYWORD
};
TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY);
TokenSet TYPE_MODIFIER_KEYWORDS = TokenSet.create(SUSPEND_KEYWORD);
TokenSet TYPE_ARGUMENT_MODIFIER_KEYWORDS = TokenSet.create(IN_KEYWORD, OUT_KEYWORD);
TokenSet RESERVED_VALUE_PARAMETER_MODIFIER_KEYWORDS = TokenSet.create(OUT_KEYWORD, VARARG_KEYWORD);
TokenSet VISIBILITY_MODIFIERS = TokenSet.create(PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD);
3.7.2 关键字(保留字)
TokenSet KEYWORDS = TokenSet.create(PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD,
THIS_KEYWORD, SUPER_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD,
NULL_KEYWORD,
TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD,
IN_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD, CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD,
ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, TRY_KEYWORD, WHEN_KEYWORD,
NOT_IN, NOT_IS, AS_SAFE,
TYPEOF_KEYWORD
);
TokenSet SOFT_KEYWORDS = TokenSet.create(FILE_KEYWORD, IMPORT_KEYWORD, WHERE_KEYWORD, BY_KEYWORD, GET_KEYWORD,
SET_KEYWORD, ABSTRACT_KEYWORD, ENUM_KEYWORD, OPEN_KEYWORD, INNER_KEYWORD,
OVERRIDE_KEYWORD, PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD,
CATCH_KEYWORD, FINALLY_KEYWORD, OUT_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD, REIFIED_KEYWORD,
DYNAMIC_KEYWORD, COMPANION_KEYWORD, CONSTRUCTOR_KEYWORD, INIT_KEYWORD, SEALED_KEYWORD,
FIELD_KEYWORD, PROPERTY_KEYWORD, RECEIVER_KEYWORD, PARAM_KEYWORD, SETPARAM_KEYWORD,
DELEGATE_KEYWORD,
LATEINIT_KEYWORD,
DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD,
ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD, CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD,
SUSPEND_KEYWORD, HEADER_KEYWORD, IMPL_KEYWORD
);
其中,对应的关键字如下:
KtKeywordToken PACKAGE_KEYWORD = KtKeywordToken.keyword("package");
KtKeywordToken AS_KEYWORD = KtKeywordToken.keyword("as");
KtKeywordToken TYPE_ALIAS_KEYWORD = KtKeywordToken.keyword("typealias");
KtKeywordToken CLASS_KEYWORD = KtKeywordToken.keyword("class");
KtKeywordToken THIS_KEYWORD = KtKeywordToken.keyword("this");
KtKeywordToken SUPER_KEYWORD = KtKeywordToken.keyword("super");
KtKeywordToken VAL_KEYWORD = KtKeywordToken.keyword("val");
KtKeywordToken VAR_KEYWORD = KtKeywordToken.keyword("var");
KtKeywordToken FUN_KEYWORD = KtKeywordToken.keyword("fun");
KtKeywordToken FOR_KEYWORD = KtKeywordToken.keyword("for");
KtKeywordToken NULL_KEYWORD = KtKeywordToken.keyword("null");
KtKeywordToken TRUE_KEYWORD = KtKeywordToken.keyword("true");
KtKeywordToken FALSE_KEYWORD = KtKeywordToken.keyword("false");
KtKeywordToken IS_KEYWORD = KtKeywordToken.keyword("is");
KtModifierKeywordToken IN_KEYWORD = KtModifierKeywordToken.keywordModifier("in");
KtKeywordToken THROW_KEYWORD = KtKeywordToken.keyword("throw");
KtKeywordToken RETURN_KEYWORD = KtKeywordToken.keyword("return");
KtKeywordToken BREAK_KEYWORD = KtKeywordToken.keyword("break");
KtKeywordToken CONTINUE_KEYWORD = KtKeywordToken.keyword("continue");
KtKeywordToken OBJECT_KEYWORD = KtKeywordToken.keyword("object");
KtKeywordToken IF_KEYWORD = KtKeywordToken.keyword("if");
KtKeywordToken TRY_KEYWORD = KtKeywordToken.keyword("try");
KtKeywordToken ELSE_KEYWORD = KtKeywordToken.keyword("else");
KtKeywordToken WHILE_KEYWORD = KtKeywordToken.keyword("while");
KtKeywordToken DO_KEYWORD = KtKeywordToken.keyword("do");
KtKeywordToken WHEN_KEYWORD = KtKeywordToken.keyword("when");
KtKeywordToken INTERFACE_KEYWORD = KtKeywordToken.keyword("interface");
// Reserved for future use:
KtKeywordToken TYPEOF_KEYWORD = KtKeywordToken.keyword("typeof");
...
KtKeywordToken FILE_KEYWORD = KtKeywordToken.softKeyword("file");
KtKeywordToken FIELD_KEYWORD = KtKeywordToken.softKeyword("field");
KtKeywordToken PROPERTY_KEYWORD = KtKeywordToken.softKeyword("property");
KtKeywordToken RECEIVER_KEYWORD = KtKeywordToken.softKeyword("receiver");
KtKeywordToken PARAM_KEYWORD = KtKeywordToken.softKeyword("param");
KtKeywordToken SETPARAM_KEYWORD = KtKeywordToken.softKeyword("setparam");
KtKeywordToken DELEGATE_KEYWORD = KtKeywordToken.softKeyword("delegate");
KtKeywordToken IMPORT_KEYWORD = KtKeywordToken.softKeyword("import");
KtKeywordToken WHERE_KEYWORD = KtKeywordToken.softKeyword("where");
KtKeywordToken BY_KEYWORD = KtKeywordToken.softKeyword("by");
KtKeywordToken GET_KEYWORD = KtKeywordToken.softKeyword("get");
KtKeywordToken SET_KEYWORD = KtKeywordToken.softKeyword("set");
KtKeywordToken CONSTRUCTOR_KEYWORD = KtKeywordToken.softKeyword("constructor");
KtKeywordToken INIT_KEYWORD = KtKeywordToken.softKeyword("init");
KtModifierKeywordToken ABSTRACT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("abstract");
KtModifierKeywordToken ENUM_KEYWORD = KtModifierKeywordToken.softKeywordModifier("enum");
KtModifierKeywordToken OPEN_KEYWORD = KtModifierKeywordToken.softKeywordModifier("open");
KtModifierKeywordToken INNER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inner");
KtModifierKeywordToken OVERRIDE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("override");
KtModifierKeywordToken PRIVATE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("private");
KtModifierKeywordToken PUBLIC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("public");
KtModifierKeywordToken INTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("internal");
KtModifierKeywordToken PROTECTED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("protected");
KtKeywordToken CATCH_KEYWORD = KtKeywordToken.softKeyword("catch");
KtModifierKeywordToken OUT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("out");
KtModifierKeywordToken VARARG_KEYWORD = KtModifierKeywordToken.softKeywordModifier("vararg");
KtModifierKeywordToken REIFIED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("reified");
KtKeywordToken DYNAMIC_KEYWORD = KtKeywordToken.softKeyword("dynamic");
KtModifierKeywordToken COMPANION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("companion");
KtModifierKeywordToken SEALED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("sealed");
KtModifierKeywordToken DEFAULT_VISIBILITY_KEYWORD = PUBLIC_KEYWORD;
KtKeywordToken FINALLY_KEYWORD = KtKeywordToken.softKeyword("finally");
KtModifierKeywordToken FINAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("final");
KtModifierKeywordToken LATEINIT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("lateinit");
KtModifierKeywordToken DATA_KEYWORD = KtModifierKeywordToken.softKeywordModifier("data");
KtModifierKeywordToken INLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inline");
KtModifierKeywordToken NOINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("noinline");
KtModifierKeywordToken TAILREC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("tailrec");
KtModifierKeywordToken EXTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("external");
KtModifierKeywordToken ANNOTATION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("annotation");
KtModifierKeywordToken CROSSINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("crossinline");
KtModifierKeywordToken OPERATOR_KEYWORD = KtModifierKeywordToken.softKeywordModifier("operator");
KtModifierKeywordToken INFIX_KEYWORD = KtModifierKeywordToken.softKeywordModifier("infix");
KtModifierKeywordToken CONST_KEYWORD = KtModifierKeywordToken.softKeywordModifier("const");
KtModifierKeywordToken SUSPEND_KEYWORD = KtModifierKeywordToken.softKeywordModifier("suspend");
KtModifierKeywordToken HEADER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("header");
KtModifierKeywordToken IMPL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("impl");
this 关键字
this关键字持有当前对象的引用。我们可以使用this来引用变量或者成员函数,也可以使用return this,来返回某个类的引用。
代码示例
class ThisDemo {
val thisis = "THIS IS"
fun whatIsThis(): ThisDemo {
println(this.thisis) //引用变量
this.howIsThis()// 引用成员函数
return this // 返回此类的引用
}
fun howIsThis(){
println("HOW IS THIS ?")
}
}
测试代码
@Test
fun testThisDemo(){
val demo = ThisDemo()
println(demo.whatIsThis())
}
输出
THIS IS
HOW IS THIS ?
com.easy.kotlin.ThisDemo@475232fc
在类的成员中,this 指向的是该类的当前对象。在扩展函数或者带接收者的函数字面值中, this 表示在点左侧传递的 接收者参数。
代码示例:
>>> val sum = fun Int.(x:Int):Int = this + x
>>> sum
kotlin.Int.(kotlin.Int) -> kotlin.Int
>>> 1.sum(1)
2
>>> val concat = fun String.(x:Any) = this + x
>>> "abc".concat(123)
abc123
>>> "abc".concat(true)
abctrue
如果 this 没有限定符,它指的是最内层的包含它的作用域。如果我们想要引用其他作用域中的 this,可以使用 this@label 标签。
代码示例:
class Outer {
val oh = "Oh!"
inner class Inner {
fun m() {
val outer = this@Outer
val inner = this@Inner
val pthis = this
println("outer=" + outer)
println("inner=" + inner)
println("pthis=" + pthis)
println(this@Outer.oh)
val fun1 = hello@ fun String.() {
val d1 = this // fun1 的接收者
println("d1" + d1)
}
val fun2 = { s: String ->
val d2 = this
println("d2=" + d2)
}
"abc".fun1()
fun2
}
}
}
测试代码:
@Test
fun testThisKeyWord() {
val outer = Outer()
outer.Inner().m()
}
输出
outer=com.easy.kotlin.Outer@5114e183
inner=com.easy.kotlin.Outer$Inner@5aa8ac7f
pthis=com.easy.kotlin.Outer$Inner@5aa8ac7f
Oh!
d1abc
super 关键字
super关键字持有指向其父类的引用。
代码示例:
open class Father {
open val firstName = "Chen"
open val lastName = "Jason"
fun ff() {
println("FFF")
}
}
class Son : Father {
override var firstName = super.firstName
override var lastName = "Jack"
constructor(lastName: String) {
this.lastName = lastName
}
fun love() {
super.ff() // 调用父类方法
println(super.firstName + " " + super.lastName + " Love " + this.firstName + " " + this.lastName)
}
}
测试代码
@Test
fun testSuperKeyWord() {
val son = Son("Harry")
son.love()
}
输出
FFF
Chen Jason Love Chen Harry
3.7.3 操作符和操作符的重载
Kotlin 允许我们为自己的类型提供预定义的一组操作符的实现。这些操作符具有固定的符号表示(如 + 或 *)和固定的优先级。这些操作符的符号定义如下:
KtSingleValueToken LBRACKET = new KtSingleValueToken("LBRACKET", "[");
KtSingleValueToken RBRACKET = new KtSingleValueToken("RBRACKET", "]");
KtSingleValueToken LBRACE = new KtSingleValueToken("LBRACE", "{");
KtSingleValueToken RBRACE = new KtSingleValueToken("RBRACE", "}");
KtSingleValueToken LPAR = new KtSingleValueToken("LPAR", "(");
KtSingleValueToken RPAR = new KtSingleValueToken("RPAR", ")");
KtSingleValueToken DOT = new KtSingleValueToken("DOT", ".");
KtSingleValueToken PLUSPLUS = new KtSingleValueToken("PLUSPLUS", "++");
KtSingleValueToken MINUSMINUS = new KtSingleValueToken("MINUSMINUS", "--");
KtSingleValueToken MUL = new KtSingleValueToken("MUL", "*");
KtSingleValueToken PLUS = new KtSingleValueToken("PLUS", "+");
KtSingleValueToken MINUS = new KtSingleValueToken("MINUS", "-");
KtSingleValueToken EXCL = new KtSingleValueToken("EXCL", "!");
KtSingleValueToken DIV = new KtSingleValueToken("DIV", "/");
KtSingleValueToken PERC = new KtSingleValueToken("PERC", "%");
KtSingleValueToken LT = new KtSingleValueToken("LT", "<");
KtSingleValueToken GT = new KtSingleValueToken("GT", ">");
KtSingleValueToken LTEQ = new KtSingleValueToken("LTEQ", "<=");
KtSingleValueToken GTEQ = new KtSingleValueToken("GTEQ", ">=");
KtSingleValueToken EQEQEQ = new KtSingleValueToken("EQEQEQ", "===");
KtSingleValueToken ARROW = new KtSingleValueToken("ARROW", "->");
KtSingleValueToken DOUBLE_ARROW = new KtSingleValueToken("DOUBLE_ARROW", "=>");
KtSingleValueToken EXCLEQEQEQ = new KtSingleValueToken("EXCLEQEQEQ", "!==");
KtSingleValueToken EQEQ = new KtSingleValueToken("EQEQ", "==");
KtSingleValueToken EXCLEQ = new KtSingleValueToken("EXCLEQ", "!=");
KtSingleValueToken EXCLEXCL = new KtSingleValueToken("EXCLEXCL", "!!");
KtSingleValueToken ANDAND = new KtSingleValueToken("ANDAND", "&&");
KtSingleValueToken OROR = new KtSingleValueToken("OROR", "||");
KtSingleValueToken SAFE_ACCESS = new KtSingleValueToken("SAFE_ACCESS", "?.");
KtSingleValueToken ELVIS = new KtSingleValueToken("ELVIS", "?:");
KtSingleValueToken QUEST = new KtSingleValueToken("QUEST", "?");
KtSingleValueToken COLONCOLON = new KtSingleValueToken("COLONCOLON", "::");
KtSingleValueToken COLON = new KtSingleValueToken("COLON", ":");
KtSingleValueToken SEMICOLON = new KtSingleValueToken("SEMICOLON", ";");
KtSingleValueToken DOUBLE_SEMICOLON = new KtSingleValueToken("DOUBLE_SEMICOLON", ";;");
KtSingleValueToken RANGE = new KtSingleValueToken("RANGE", "..");
KtSingleValueToken EQ = new KtSingleValueToken("EQ", "=");
KtSingleValueToken MULTEQ = new KtSingleValueToken("MULTEQ", "*=");
KtSingleValueToken DIVEQ = new KtSingleValueToken("DIVEQ", "/=");
KtSingleValueToken PERCEQ = new KtSingleValueToken("PERCEQ", "%=");
KtSingleValueToken PLUSEQ = new KtSingleValueToken("PLUSEQ", "+=");
KtSingleValueToken MINUSEQ = new KtSingleValueToken("MINUSEQ", "-=");
KtKeywordToken NOT_IN = KtKeywordToken.keyword("NOT_IN", "!in");
KtKeywordToken NOT_IS = KtKeywordToken.keyword("NOT_IS", "!is");
KtSingleValueToken HASH = new KtSingleValueToken("HASH", "#");
KtSingleValueToken AT = new KtSingleValueToken("AT", "@");
KtSingleValueToken COMMA = new KtSingleValueToken("COMMA", ",");
3.7.4 操作符优先级(Precedence)
优先级
|
标题
|
符号
|
最高
|
后缀(Postfix )
|
++, --, ., ?., ?
|
|
前缀(Prefix)
|
-, +, ++, --, !, labelDefinition@
|
|
右手类型运算(Type RHS,right-hand side class type (RHS) )
|
:, as, as?
|
|
乘除取余(Multiplicative)
|
*, /, %
|
|
加减(Additive )
|
+, -
|
|
区间范围(Range)
|
..
|
|
Infix函数
|
例如,给Int定义扩展 infix fun Int.shl(x: Int): Int {...},这样调用 1 shl 2,等同于1.shl(2)
|
|
Elvis操作符
|
?:
|
|
命名检查符(Named checks)
|
in, !in, is, !is
|
|
比较大小(Comparison)
|
<, >, <=, >=
|
|
相等性判断(Equality)
|
==, \!==
|
|
与 (Conjunction)
|
&&
|
|
或 (Disjunction)
|
ll
|
最低
|
赋值(Assignment)
|
=, +=, -=, *=, /=, %=
|
注:Markdown表格语法:ll是||。
为实现这些的操作符,Kotlin为二元操作符左侧的类型和一元操作符的参数类型,提供了相应的函数或扩展函数。例如在kotlin/core/builtins/native/kotlin/Primitives.kt代码中,对基本类型Int的操作符的实现代码如下:
public class Int private constructor() : Number(), Comparable<Int> {
...
/**
* Compares this value with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
* or a positive number if it's greater than other.
*/
public operator fun compareTo(other: Byte): Int
/**
* Compares this value with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
* or a positive number if it's greater than other.
*/
public operator fun compareTo(other: Short): Int
/**
* Compares this value with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
* or a positive number if it's greater than other.
*/
public override operator fun compareTo(other: Int): Int
/**
* Compares this value with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
* or a positive number if it's greater than other.
*/
public operator fun compareTo(other: Long): Int
/**
* Compares this value with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
* or a positive number if it's greater than other.
*/
public operator fun compareTo(other: Float): Int
/**
* Compares this value with the specified value for order.
* Returns zero if this value is equal to the specified other value, a negative number if it's less than other,
* or a positive number if it's greater than other.
*/
public operator fun compareTo(other: Double): Int
/** Adds the other value to this value. */
public operator fun plus(other: Byte): Int
/** Adds the other value to this value. */
public operator fun plus(other: Short): Int
/** Adds the other value to this value. */
public operator fun plus(other: Int): Int
/** Adds the other value to this value. */
public operator fun plus(other: Long): Long
/** Adds the other value to this value. */
public operator fun plus(other: Float): Float
/** Adds the other value to this value. */
public operator fun plus(other: Double): Double
/** Subtracts the other value from this value. */
public operator fun minus(other: Byte): Int
/** Subtracts the other value from this value. */
public operator fun minus(other: Short): Int
/** Subtracts the other value from this value. */
public operator fun minus(other: Int): Int
/** Subtracts the other value from this value. */
public operator fun minus(other: Long): Long
/** Subtracts the other value from this value. */
public operator fun minus(other: Float): Float
/** Subtracts the other value from this value. */
public operator fun minus(other: Double): Double
/** Multiplies this value by the other value. */
public operator fun times(other: Byte): Int
/** Multiplies this value by the other value. */
public operator fun times(other: Short): Int
/** Multiplies this value by the other value. */
public operator fun times(other: Int): Int
/** Multiplies this value by the other value. */
public operator fun times(other: Long): Long
/** Multiplies this value by the other value. */
public operator fun times(other: Float): Float
/** Multiplies this value by the other value. */
public operator fun times(other: Double): Double
/** Divides this value by the other value. */
public operator fun div(other: Byte): Int
/** Divides this value by the other value. */
public operator fun div(other: Short): Int
/** Divides this value by the other value. */
public operator fun div(other: Int): Int
/** Divides this value by the other value. */
public operator fun div(other: Long): Long
/** Divides this value by the other value. */
public operator fun div(other: Float): Float
/** Divides this value by the other value. */
public operator fun div(other: Double): Double
/** Calculates the remainder of dividing this value by the other value. */
@Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
public operator fun mod(other: Byte): Int
/** Calculates the remainder of dividing this value by the other value. */
@Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
public operator fun mod(other: Short): Int
/** Calculates the remainder of dividing this value by the other value. */
@Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
public operator fun mod(other: Int): Int
/** Calculates the remainder of dividing this value by the other value. */
@Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
public operator fun mod(other: Long): Long
/** Calculates the remainder of dividing this value by the other value. */
@Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
public operator fun mod(other: Float): Float
/** Calculates the remainder of dividing this value by the other value. */
@Deprecated("Use rem(other) instead", ReplaceWith("rem(other)"), DeprecationLevel.WARNING)
public operator fun mod(other: Double): Double
/** Calculates the remainder of dividing this value by the other value. */
@SinceKotlin("1.1")
public operator fun rem(other: Byte): Int
/** Calculates the remainder of dividing this value by the other value. */
@SinceKotlin("1.1")
public operator fun rem(other: Short): Int
/** Calculates the remainder of dividing this value by the other value. */
@SinceKotlin("1.1")
public operator fun rem(other: Int): Int
/** Calculates the remainder of dividing this value by the other value. */
@SinceKotlin("1.1")
public operator fun rem(other: Long): Long
/** Calculates the remainder of dividing this value by the other value. */
@SinceKotlin("1.1")
public operator fun rem(other: Float): Float
/** Calculates the remainder of dividing this value by the other value. */
@SinceKotlin("1.1")
public operator fun rem(other: Double): Double
/** Increments this value. */
public operator fun inc(): Int
/** Decrements this value. */
public operator fun dec(): Int
/** Returns this value. */
public operator fun unaryPlus(): Int
/** Returns the negative of this value. */
public operator fun unaryMinus(): Int
/** Creates a range from this value to the specified [other] value. */
public operator fun rangeTo(other: Byte): IntRange
/** Creates a range from this value to the specified [other] value. */
public operator fun rangeTo(other: Short): IntRange
/** Creates a range from this value to the specified [other] value. */
public operator fun rangeTo(other: Int): IntRange
/** Creates a range from this value to the specified [other] value. */
public operator fun rangeTo(other: Long): LongRange
/** Shifts this value left by [bits]. */
public infix fun shl(bitCount: Int): Int
/** Shifts this value right by [bits], filling the leftmost bits with copies of the sign bit. */
public infix fun shr(bitCount: Int): Int
/** Shifts this value right by [bits], filling the leftmost bits with zeros. */
public infix fun ushr(bitCount: Int): Int
/** Performs a bitwise AND operation between the two values. */
public infix fun and(other: Int): Int
/** Performs a bitwise OR operation between the two values. */
public infix fun or(other: Int): Int
/** Performs a bitwise XOR operation between the two values. */
public infix fun xor(other: Int): Int
/** Inverts the bits in this value. */
public fun inv(): Int
public override fun toByte(): Byte
public override fun toChar(): Char
public override fun toShort(): Short
public override fun toInt(): Int
public override fun toLong(): Long
public override fun toFloat(): Float
public override fun toDouble(): Double
}
从源代码我们可以看出,重载操作符的函数需要用 operator 修饰符标记。中缀操作符的函数使用infix修饰符标记。
3.7.5 一元操作符(unary operation)
![](data:image/png;base64,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)
例如,当编译器处理表达式 +a 时,它将执行以下步骤:
1.确定 a 的类型,令其为 T。
2.为接收者 T 查找一个带有 operator 修饰符的无参函数 unaryPlus(),即成员函数或扩展函数。
3.如果函数不存在或不明确,则导致编译错误。
4.如果函数存在且其返回类型为 R,那就表达式 +a 具有类型 R。
编译器对这些操作以及所有其他操作都针对基本类型做了优化,不会引入函数调用的开销。
以下是如何重载一元减运算符的示例:
package com.easy.kotlin
class OperatorDemo {
}
data class Point(val x: Int, val y: Int)
operator fun Point.unaryMinus() = Point(-x, -y)
测试代码:
package com.easy.kotlin
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
@RunWith(JUnit4::class)
class OperatorDemoTest {
@Test
fun testPointUnaryMinus() {
val p = Point(1, 1)
val np = -p
println(np) //Point(x=-1, y=-1)
}
}
递增和递减
![](data:image/png;base64,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)
inc() 和 dec() 函数必须返回一个值,它用于赋值给使用 ++ 或 -- 操作的变量。编译器执行以下步骤来解析后缀形式的操作符,例如 a++:
1.确定 a 的类型,令其为 T。
2.查找一个适用于类型为 T 的接收者的、带有 operator 修饰符的无参数函数 inc()。
3.检查函数的返回类型是 T 的子类型。
计算表达式的步骤是:
1.把 a 的初始值存储到临时存储 a_ 中
2.把 a.inc() 结果赋值给 a
3.把 a_ 作为表达式的结果返回
( a-- 同理分析)。
对于前缀形式 ++a 和 --a 解析步骤类似,但是返回值是取的新值来返回:
1.把 a.inc() 结果赋值给 a
2.把 a 的新值a+1作为表达式结果返回
3.( --a 同理分析)。
3.7.6 二元操作符
算术运算符
![](data:image/png;base64,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)
代码示例
>>> val a=10
>>> val b=3
>>> a+b
13
>>> a-b
7
>>> a/b
3
>>> a%b
1
>>> a..b
10..3
>>> b..a
3..10
字符串的+运算符重载
先用代码举个例子:
>>> ""+1
1
>>> 1+""
error: none of the following functions can be called with the arguments supplied:
public final operator fun plus(other: Byte): Int defined in kotlin.Int
public final operator fun plus(other: Double): Double defined in kotlin.Int
public final operator fun plus(other: Float): Float defined in kotlin.Int
public final operator fun plus(other: Int): Int defined in kotlin.Int
public final operator fun plus(other: Long): Long defined in kotlin.Int
public final operator fun plus(other: Short): Int defined in kotlin.Int
1+""
^
从上面的示例,我们可以看出,在Kotlin中1+""是不允许的(这地方,相比Scala,写这样的Kotlin代码就显得不大友好),只能显式调用toString来相加:
>>> 1.toString()+""
1
自定义重载的 + 运算符
下面我们使用一个计数类 Counter 重载的 + 运算符来增加index的计数值。
代码示例
data class Counter(var index: Int)
operator fun Counter.plus(increment: Int): Counter {
return Counter(index + increment)
}
测试类
package com.easy.kotlin
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
@RunWith(JUnit4::class)
class OperatorDemoTest
@Test
fun testCounterIndexPlus() {
val c = Counter(1)
val cplus = c + 10
println(cplus) //Counter(index=11)
}
}
in 操作符
![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAVoAAAC+CAYAAAB088dWAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAABcZSURBVHhe7d1PaBXn+sDxRxOkKXaRQJQeW40WswpN3YhpXITfIpsquPkVtYsbBJGKCHK7qEEaLKJdeBFK8CIFyV34h3YjaDdnccnC3BQ31pJVSjXamosGdKE0FzHe+77vvHPOzJx/M+ec92TOOd8PjDkzOc6ZzPvOM+/7vO8ka/6rCADAmbX2KwDAEQItADhGoAUAxwi0AOAYgRYAHCPQAoBjBFoAcIxACwCOEWgBwDECLQA4RqAFAMcItADgGIEWABwj0AKAYwRaAHCMQAsAjsX6xd/379+3rwCgNWzbts2+ci92oN20aZNdQyt6/PgxZYy2oet7IwMtqQMAcIxACwCOEWgBwDECLQA4RqAFAMcItADgGIEWABwj0AKAYwRaAHCMQAsAjhFoAcAxAi0AOEagBQDHCLQA4BiBFgAcI9ACgGOpCrTPfvxChoe/kFtLdkMlS7fki4tzdqW0xPtFa9P15q+35JldzfllUtWTYfnix4LvADVp6hbtszvTMnvlSMMvjLmLw+qCnBQT4vVFSxAvy7vR6XNWxXmKeTNN7Kdzstcvw4i+93vsK6A+GvqnbPQFt/fsrF2r3oG/z8ixD73X/j6D26K894icvHFe9vTajTUI7U+1i+bunJUj6hiGxm/K+U+a8yKtz5+yeSa3/rpXzv1kV3OGAud+TiaHj8g1s107ICfHF+RcsF58dklmjg6Yl375Bs9t0npUvFz8Yw0cm27Rfn6tbF1Ca2j0n7JJ1d8Mqy4g+hfMAbk0c0y8yzPMaaD192cu0oW6fUaj1etvhunW/tQWG9j0OflHn9z82x7psQFWgkHMnDMJlZv+/0ckH2g1P7CGA6At9w/C7w0y+7oSDPJReh+qIL+03yfQtg3+ZlhiPbLny5MytEu9rKH7ri9mr3tbefFaU7Nybl9gu7pAc9uK5f/axMDRGRl7uDeSztFBdkr6blQXwHo+GZeTqnyvfR5MPahy/8sBkStHZPIXuylAl+eRK7o1O17mxqf28bd8EH72+4L6d0j63vXWgXppgRZtULRbGk/iFkyTt16LqVeLNiTUovX5QVedu3/bFu2NPpn6RmRcvW+xSIvW0LnaH9R7/l/tK3DOi9UZvwUcTEF4SqU2kmnmFBE8LZ868LpzdqUK1VRy78LrK5laSKwFu5h1CbT2vJS166Sc/OCcTOv0wvtXvUA7MyLTNvj2/VAi0JaRD7bjIt/YQFoQZCurmGrQwX7fORXtCbTNruVTB7prOTNTfLk5PqTeoSt68e/rJVfBzWh/vutebubB4kPVutnVJxm7Dkc+PJYvq7+rbr2mAuvNQPnNqFbrx1uGZPbhovd9Y0BGPpuV6Tu1JFx02sYLsvoGmDTI6tbuwm/qy64R+bhFeilIj+bN0fbukfPm4r0k9pIuwV5AH/QFuq81erdP3Q5EFn5v10xsebqFqVu2Q7vUWTLTqIZDedSenSMydGVaglOrMgXB12th5nLgBVPDdBrA+54/UOYH+GufF3t/BUv/kmndEq5nPQGsxqUObLcr/qScMnQrKZf38/KyC6W6c8HPrdCdjJXWMPuQ8p/ZhOqTo83nyE1aRWyO9kuRs7YMQukWk2qoPOsgmBP/+I7NvyrlUzeRfGylVEIwHfSuzgf3yfno+1swZdSuWjd1kGuBFltumlFlUS0g3VLUFbn4++wSGlwpb+4HfYEfkEu6K3vliAyXmfweTWtc+kxtjHZ9zcWXkT51vNEWWHvTgU0FWXu+QoHIL3vT2vQfElDv/0ckn6tuilMVbnQ9n5zPlUU42OkgH0wh6RkF0XIrxT+WAzKi9uk/CFOurgBJpCJ1MHdRtzyG5OSX52V8fEiu3S5Wwb0LqdhUnpLshTs0flAGdP4wRrCNp0f6PlBffltQlyg8XmC7+X/TJlVguvt6YMymDrx13SrVrddIa1OrZ48nKZs2MPVErZpgfuOkDK3CU4doTaseaP3uuj/fseeTMTlwZSqcX9NdNt0lVd2/g+/GrfjqYv7Ga82O+d37OgZbnVOUn6blXzXM3W1ZuptuW7D5HsElm0vXN0x7Yx33tuSCrPp/phdRkQ7UNnjnFi9lMXt2b2S7WsrOay5STzTdClfHr/fnB1vm2aJaqxhovYvF5ETVxTieq+QDcnBc5NwPXiA0AyJ6YGX8pun+9fTGSRr4LSY9gyEypSsQbGtprfS836f+nZWFf3vrPjMQVOIZeiiqW35Np3Jmzsue971N0z94U6bKd++DImmBQCA39SS0XS3lUk2/XDUta781G6LqijcTBqjN6gRa3YIxrRq7HhnpNU8C/aZanao14s1rDEzrqiS3b3sxF5uqY4NtsLWS2Icj5sKOpjmYSqboHoNuSYZSB/ZBkp16Clj45jdyNEH51pOuK/oYQzf6MJ1G8I/NlK30SR/Tv5BQgwOt7fKZXJwOhHYQrIBusfgtlHKPUEYEuqDRi7mAba3Mnr0ao/UZ7qp6wVnP/VRfQmkOB1PJmlHZ1EHtvF5Dvjy8pUzqQC8FqaI5mfTrYazBVVu2QBUaF2j9lqb4F16pQOgFtclfBuSYCsQj/1QXTpkc27Mfp+wFdlZuiR3djtkF9UawC4/Dn79p0hqmRaZ/8Yg+Zm/xWzgDR3XwmJVz3/jHtygLuhu6hUcjXJm7OCmLgZkH+aVM6kAvoTrhT0PTN/sKN2RfuRQDUEHjAq0/xadM68ELcF5Q86buREayI60S8+jlP0dM4L70mfcLXapOBZgbgRdgp3dHLtJSKQh1yR3TrbZQ93hIRna2dXu2fOogKpRmKddq9Mr3yJUFWahlANKUc4UgawZfvbqQW/TPolrqrTJvGo21yr9Uxh+08tYqTQT3nmnXOVDVKv7Lguwt+gtLSlzQZSVo2RTjpyz0a91tjj2okx71eWDBltHDsSLnQJeN/n0GY7KwL19GuswP/p5/CKFYWfgzU0y5l7xRe2Vf9iGSYGqpCcsI9dPoBxZWN9Caij8tI6V+iQcapl6Btv6eqeB9Vc7KwQqtyRiBFrDaK9AiNdIbaIH6a3SgXcV5tADQHgi0AOAYgRYAHCPQAoBjBFoAcIxACwCOEWgBwDECLQA4RqAFAMcItADgGIEWABwj0AKAYwRaAHCMQAsAjhFoAcAxAi0AOEagBQDHYv+FBQBoJan8UzaNPCg0HmWMdtLo+k7qAAAcI9ACgGMEWgBwjEALAI4RaAHAMQItADhGoAUAxwi0AOAYgRYAHCPQAoBjDX0Ed2VlRV6/fi1v3ryxW1DM2rVrpbOzUzo6OuwW9yhjrJZmru9xNaxFqy/AV69ecQHGoM+RPlf6nDUTyhjVaNb6nkTDAq1u5SCZZjtnlDFq0cr1p2GBllZOcs12zihj1KKV6w+DYQDgGIEWABwj0AKAYwRaAHCMQAsAjhFoAcAxAi0AONZGgfap3D+6X+4N7pf5u3aTK0+yMteIz2liz298pcrisizadWgNrKNFmDI5mpXndj0RU+e/kvtP7DpCaNECVZuTeRUU5248tetN7O5leTQxL12HR6Xbbkpk46j0jM3Li1FunsW0UaDdINsuXpfBe9elf4fdBKTKKtVR3Rody0rH6W9r+tzMiW/lneGsLFXbKm5htGiBNrd49bKsDB+STfs22C3VUjeKiUPSMXNZHrdCK7+OGvZrEpeXl+2ruHS+6ri8mLGrir7jDiSuDNH99Ms72a9l20a7aun81KPsbtl8MSNLg2fEP9qqPlO3EFQXat3UdVk/vV+Wpux2VZk3X0zWNevq6rKv3Gp0GZvzPdEnvfd2ystaz3eO7srn9yUyqvZ/SDJ2zbBlk/89UdH3ePsQVXa9D/Uxztvt+fd5x+5vL1TwM6hu+T3VYsyLfmb962jBMY6dksETA3YlIFBXS7ZmKx5/2OIFXefLv6eUZqrvSaS2Rbt4YVJkwutGmUUV3MrE8SryYfnumN5HWepO/Gjwe+nMhj+zuoGJfnn1napwoiq4+RlOSZfe/4U5+33I8II8s0Gt5vOtg4EOPjqgmPOtFxXEA+dbB597Nqj47+lVAWSpyCDO8th+efTgU/u+cJe4e9/XdrsqU7WuA52/P72Egp4OZNM7A9+3+woNBNa3jnpBVlSwtu9Ry+at3xc9r89nb6ubzqisLxVkYx1/WGZE/wxZebkKA3ppldpAmzkRuaPv2KMKWGQl+7PT/E/XVOBzd+w0F9Krh9V0g+ZlZXuwFTEgvaf7VVD5npFZ38x8uCVly3j5u6Q5PtUiVP+nsNU2IP259TlZUi08HRSDLbfMCR0s5+XF1cgNUPc+cv93g3SPqrKb+SPQWo5p46gMhI5JBdXDtQWiSnV0+YFqyQ7vlu7A9aNvDoUt1qfyPKveO7azdMuzmuOv6bppTU2Uo90gb223L50pc2evQtdIsIKqyr6lT/07L68ZlrWi59uWcdKA9uRn+VN1u6PnO+TuHbPPdVuiaYkBWT+mvvy6GAruHaMfVTf6HkfmPan+bwlUrqNdW/VNQbV8Kw5KPZXX6rx1bE2Yqql4/BukUzeKHhBofekNtLrLMujNKfSXXK6zWdV0gbUHEySSWvxDdX/7pbNiQrDMe6pprcakc5bBeqzTFy7/loBJbegUhEkz2M+sIWXV6ONvRekMtP6ARSjfpvNp9vvNKnZAaF9et/c90/WMzdzAauwpJP3MmLyBIT24la/Hg9lD7m+4Ow6Fr5upM1UF21U7/haTykDrJehV4R4s0xVsQovTeuS2T96KjCbDNycvda9le6ag2+63qooOhm7MyDr1ZXm6TCAxecN5+XM2+v+9z6wuVVCpi2x/nrFPC2YQNFLmhA22kfSIu+OvMiXRwlIZaP1cZv6i8B5NbOrUwd3L5vi7ppJPeWkXixf0lKVR6Q0Nvmj2gleKD4b6A41nIoF4TuZzrTjvPSsTk6HBSP8ze6qaUmZzyiUHOL1AJlN38iP0enaE0663vlaiMwJK3cDsIF/w+EKqPP6S+fD2lc7Uger2bDYXxXGbFzourw9XmToI5nrNXED9mKBdd/UEy8aP5G1VQfUUIe/49WcvmO5XLU/etJLuod2q+6mnCeXP0dKvqtyLzr20A1ZKqZann5fM1xm93JH1gaCt37P5tOTLv+xnxuM9DRWoU2rJB3s9bUvPagj8nN+9J5ujXe+61lH9mXpusv3/Zjkjr/QUtIIbWL4cis8giHn8EabnNnxIeqnrOSl+YAFaqz6wgPTw8rDVPWBQwI6vlH0AogweWADQkjIHdQtVtVprfpjmqdw/fdk8zktrNoxAC7Q7/VCCng5WkONOZvGCfoxYtYwTPmbeDgi0APLjItU+efkkK8/MNDAGe4shR5ty5GjRTsjRAgCq0rBAu3YtMT2pZjtnlDFq0cr1p2E/WWdnp32FuJrtnFHGqEUr15+GBdqOjg5Zt24drZ4Y9DnS50qfs2ZCGaMazVrfk2jYYBjSjTJGO2EwDABaDIEWABwj0AKAYwRaAHCMQAsAjhFoAcAxAi0AOEagBQDHCLQA4BiBFgAci/0ILgC0kkY+ghs70G7atMmuoRU9fvyYMkbb0PWd33UAAC2EQAsAjhFoAcAxAi0AOEagBQDHCLQA4BiBFgAcI9ACgGMEWgBwjEALAI419BFc/VExPg4xrVmzxiz1UK9HcCljuFSvOt+yj+ByAdZf2s4pZQzXmrWONTTQov7SdF4pYzQCgRYAUIBACwCOEWgBwDECLQA4RqAFAMcItADgGIEWABwj0AKAY20VaBcv7Jd7g1/J/Sd2QzFPsjI3qN93WRbtJlfM8RzNynO73p7mZF6f76Lnwfve3I2ndh1GA+toIa9M5u/a1YRMnb8wZ9faRxu2aPvkrY32JdJje0a67cuWYwNjtcEpPZ7K/aNnZHn4kPTusJsSyhw8JB1TZ9ru5knqIGrjqAzcuy6D9w5Jxm4CUmWV6ujihePyYmZUei+OVn9T1Mc+NSorE8db4MYTX1sF2q6t/fYV0mODdA7bl0gv1Sp/NqWuoak6BPcdqkU8JrI8thqpj9WR4kCruyk6D5VfnHY3cnkvu5TJGeo78fMbXwWOrcYKE/nsdrrTx1XP8x3eV/F6FX1PNK9ovm/qiM0x2yW4L29MQC2jl2VFrS+P5d+nl3A5x6jvDupo7hjtUuoaW7yqfoYKKYPovsrlYk0KQVTwdnlNp0hqA+3ihUmRCd09sovtbjgLtrnu2HVzty1HXzCPHnxqj+1beWc4K0tVD2rdlsejt+XtrPfZm0/3q/1XGLBrN9lJeZTdLZtrPt9eMHs0IfKOPd962SS3Aufbf0+f9NrvD947pVpyZwoD28xleTT4vXT6+4p0iTMn7PasDiq6NWjX7dIfCFqx6nud66gOjEvqc/I/53XpeTBZpO7NyUvVmu0Y/ahkykAH9Zcj+f2Yn1mfs1LBduNH8rbqyaxkf67yumkuqQ20mRNfy7bgoNWOPaqypKRg1J1984kBu7JBukf71UX3hyzbLYnMiAqy+Z+1e9+n0iXz8uJq+43MlrIiKsjm8oIbZNvhURPklpK2/O/ekhcz/SrIhutW975D+fXce4Jd5AHpVwGp2Gd2TQX2tWOnKjuRVw+TNwbqXt8r1tGn8p9f1ZexnaFUQMFxaHfvqP/XL28PbbAbCnXv+zp049A3hR59M5i6U6L3UeN102SaKEe7Qd7abl+usnJ39sSGd0t3qGLbnOWvi21xp4+j4Hxn3jMtxKQBbXE6W+R8h5n3FJuZUjSIjsr6KkffK6utvleuo3b/5Vqd1vOHC+rf5LN1Ko2JdG/pU/8uyH/aoPeW3kAbzUepZUl1X2o2/J65YNIrPTeURurYWrq1VGBjRtbZl/HZFlycaWRl6sjKA0epK1f1vQyd2tCpKhNs7WdWn5oL56r18mhi3n4P6Qy0utLpAYSxU/mcj1oq5aVaQ4KA0K6eLMor9WXdlgTB2b+B1dhTSHRDiGsV67vu8nufp/O46kZS1TiIDrLe/Fovj+4tJojDSGWgfT57W1akX9456OeY6sNUqlrmADbCk5/lzxlHF3QqbZBtF6/LwL74P69fPzoL5hnlR+6LzdwwXdmZ2/K8TFc1M6JzsUXeEyNPWZJtgZdKdbiq78nocrDBNtJqr9jFN+dGnd/Dya6talMSzSiVgdYr2Hn5c9YvcO8Cqq0r5V+EaR7RV8d42ptGsylB4Glqfpc57iwC9f7HqkvacfpY4aCNvUlpy9OFecfcQKNqPQYHaJ7fuJyvE2YQSr3ndPB4VIttLCsy9mnhZ8bi5d1XJm4VHRhyU98rUT9T9JyXusmb/HTw+CJszjx4zvWMhvKpg6fyPKu+n/pUXn2kM3WwQ3VBVLdDd2O8fM9xeX3YbVcqOOfQVHAzdcdbdzWlzGs95T9H/5wvtqvuY9pb3Q0zIOtVmefrgVpUkFw3VaIFbKcMaV0jxVqHA9LvT3XKnfP98lj2BAKobdlJsFzOyKvT38pgbhQ/Kb3PUyqghD831+qOWd/rW0fVuZgQeWz/v1lKnltbDqVmQNinvYK53mdbvy2fOrBBPWkruFmt+W+MPyl5//79mv/m/5s3b+wr1NvatbXfL/XfuaeMUZLNI4u64SRJ85Ri5vD+qm4wVTYqaq3zur5v27bNrrmXzhYtgHSx82JXJoo90JDQ3cumRd4urVmNQAsglswJnXYpzHEnolvGY1npUC3j0AMOLY5ACyCmfK75ZdKn8izzOxPGTtUl/dBMyNG2AHK0aDfkaAEAIQRaAHCsYYF2zZo19hXqKU3nlTJGIzRjPWtooOVCrK+0nVPKGK41ax1r2GAY0q0eg2FAs2AwDABaDIEWABwj0AKAYwRaAHCMQAsAjhFoAcAxAi0AOEagBQDHCLQA4BiBFgAci/0ILgC0kkY+ghsr0AIAqkfqAAAcI9ACgGMEWgBwSuR/YhLFVlvIuPIAAAAASUVORK5CYII=)
索引访问操作符
![](data:image/png;base64,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)
方括号转换为调用带有适当数量参数的 get 和 set。
调用操作符
![](data:image/png;base64,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)
圆括号转换为调用带有适当数量参数的 invoke。
计算并赋值
![](data:image/png;base64,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)
对于赋值操作,例如 a += b,编译器会试着生成 a = a + b 的代码(这里包含类型检查:a + b 的类型必须是 a 的子类型)。
相等与不等操作符
Kotlin 中有两种类型的相等性:
1.引用相等 === !==(两个引用指向同一对象)
2.结构相等 == !=( 使用equals() 判断)
![](data:image/png;base64,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)
这个 == 操作符有些特殊:它被翻译成一个复杂的表达式,用于筛选 null 值。
意思是:如果 a 不是 null 则调用 equals(Any?) 函数并返回其值;否则(即 a === null)就计算 b === null 的值并返回。
当与 null 显式比较时,a == null 会被自动转换为 a=== null
注意:=== 和 !==不可重载。
Elvis 操作符 ?:
在Kotin中,Elvis操作符特定是跟null比较。也就是说
y = x?:0
等价于
val y = if(x!==null) x else 0
主要用来作null安全性检查。
Elvis操作符 ?: 是一个二元运算符,如果第一个操作数为真,则返回第一个操作数,否则将计算并返回其第二个操作数。它是三元条件运算符的变体。命名灵感来自猫王的发型风格。
Kotlin中没有这样的三元运算符 true?1:0,取而代之的是if(true) 1 else 0。而Elvis操作符算是精简版的三元运算符。
我们在Java中使用的三元运算符的语法,你通常要重复变量两次, 示例:
String name = "Elvis Presley";
String displayName = (name != null) ? name : "Unknown";
取而代之,你可以使用Elvis操作符。
String name = "Elvis Presley";
String displayName = name?:"Unknown"
我们可以看出,用Elvis操作符(?:)可以把带有默认值的if/else结构写的及其短小。用Elvis操作符不用检查null(避免了NullPointerException),也不用重复变量。这个Elvis操作符功能在Spring 表达式语言 (SpEL)中提供。在Kotlin中当然就没有理由不支持这个特性。
代码示例:
>>> val x = null
>>> val y = x?:0
>>> y
0
>>> val x = false
>>> val y = x?:0
>>> y
false
>>> val x = ""
>>> val y = x?:0
>>> y
>>> val x = "abc"
>>> val y = x?:0
>>> y
abc
比较操作符
![](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXUAAAEuCAYAAABxtIL8AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAEnQAABJ0Ad5mH3gAACpsSURBVHhe7Z1PaBVZvsd/miCt6CKBROamn6YzmFUYx42MHRcyi7tpG9w8se3FuwSG5okI4fViWqRDGrFn0UNAxKFpkLxF2+LbCDqbuxhcmHFwY2fIKjIx+jp5mIBZKKYJxn6/3zmn6lbVrbr31p/cW3Xy/UAlt+pWTtU9f76/P+fUzY5fGAIAAGAFO81vAAAAFgBRBwAAi4CoAwCARUDUAQDAIiDqAABgERB1AACwCIg6AABYBEQdAAAsAqIOAAAWAVEHAACLgKgDAIBFtPTdLwsLC+YVAACArWZoaMi8ik/Loj4wMGD2QJFYWlpC2wFQEGS8CmlEHekXAACwCIg6AABYBEQdAAAsAqIOAAAWAVEHAACLgKgDAIBFQNQBAMAiIOoAAGAREHUAALAIiDoAAFgERB0AACwCog4AABYBUQcAAIuAqAMAgEVA1AEAwCIg6gAAYBG5EvWXf/2cRkc/p3ur5kAzVu/R59fnzE40scsFhWXu+ihd+6fZcXlJ9/5rlPvANWreWwAoNoX21F8+uk8Pv/+MPv/rS3OkPYhwuAIhhmXbGow5ujYqdcFbC8Y1yNz1rOtN+sEx+uE/R8P7xO8GqWReAmArbf13duIxf3zlodlLzid/maHzv9GvnTK9x4Loc4i+uPMNnewzB1PgK4+FZO7RFfqM7+HYxbv0zUe95qx8kNm/s/vnNRr9zx/MjodPv6WZcyPqZbB9j138ggavfE21vzrmaQMxCJ/xe5/QtzPnSZfgHGsV7996cO7VvTfx1D+mr+kLuvvnk5SvFgKgRuH+nV3vR9/QzMxM5Hb34jE+SwZ++PvO5hXv3o8u0he/I/bOOhRa9/XSiHyuv3xCD69csddj/9Ugt4yIqLTBXVXnYkhFNEXMR//rHpHbvvp9og/pvNNud77gv/cywu99yyX+QJ/x32q/Wo7xuVyXDfuBU9anJ+oFXfjNeVWGnNPeGA6AzmPBRGkvnfwjD3IRkRSCqoTJSSU02bQ3+pC+PuU5rrxYc8wVKYvoO0nf3Bmk6UBeWnnnzyo0k8gDZhEXAf/H1/SxN33zm7NsFLgu/xRWj+zNn/qaa5oNjIkQQmFh/4bf1/e0TIv/4F+/HoSXDqynremXZvjSGonSJHHDd02j1E0oKrxfTHGf7SOz9IsPnc5Y/A9/vbkCf66k3r//+7tUeca/j/N5v7pHn5+6TydC6kxy64vHL9KHv+n1iK5pS096p9a+3jSOISo9FIuIdA4AbSKL9EvbRV0mGT/73uwkIEneWhuLwewGrBGQ2MagA2Qj6iYnLd5uAz65+AUtXlmkysxZWjSifpGuaKH/98VIUY/GI+zH7xvRDhH0Zshktnj3PgPhR/dLiDroLIXLqQsj50JypGZrJafuCrpadVJLfzRaAbP87CFWPqSil07+2WkDJ19ucuqetjn/0SAN0iItetJgvUdP0LHv77M8p+D7z7Sg/+4LujuTIDr6v0WShNknxyHXwH6Km1OXHK8SE5lsa8RLWvwX/8oyn6omDYkW/3e7TcOJ5ywe+zE1hyFLB/3zByN04tOHdP/Rstln+ozQ/5/ZFwIGuW45pERC6j320pWQG2NCX9PHYec3Ye6B9vAHf6X3AbCZ9qVfnBDY7KZCBro7MadD9MWotIz3ug3Cb6Gl1JAqgxpfM0dklVPXKSyJeKTuP6S/m5z6iQemznxtotM1kn7xRVZ16ReT1vl1rU5VVtxXVgi+/HmzdIx/OeOy5O//PXi+/5x8tyiwmWKlX1zPOmwzIf3v2APkX8Gwvm6LMfDm/seslJBVFhLGN/Dygqmhbz/lg66naDZlFEo0yPf78JnHI7UZFlHnWYBg3es60170FScF9s+bdfl33Q6NMMsZZQtcQwyK72lQWbLotkmTdIy5l2O//5DLnKP738sKJTxdDOwlF+mXues6pP/ij9/QxYvH6IcHYcIrHnnYI+ANYO9wmr3IYxfP0ohZu9xM2FujlwZ/zb/+tehJPViMEtFviSTdotIi0l4m/eLss7etvPKQVShpJ8fToFMvn1BFRQzacHz7qQg7vjIA2EnHRd0Z8McuXlQeV+9HFfrk+2m/J6VyrHoVxNlftSqjHFL/SXvpekAzGQp76SDHFP+4T3/fVh6fM4mtIysnotIT3MajFkH/9At3MlW3L//dX4IPH0Xg5tNrm34u4Af6LHBctoZGnsvSfYuNujkkjJyT+5fyHGHHOnZgDx0Udclj1vKxF93c9AidvUj09f/o4SaiIEIhSxkl9dHb18qwMzlS8f7vBJaoeYQ9zXfG9P7bIP986J8AZOpSBduGRfr73/RXJcyc+1AfenaTIyVZJvgNnWx1ktKXWvEaDSnHf1y26CWl3Af+2+ule5HVPN/SJ2J4kIYBltEZUVerH3QIrwh4SOrR/3+xN82emPLy2DtseULSLduISVi+1Qj7wysfJxf235xguWD/MZAqsnv5pHliNpB+0Z70oFr26Gung2fpmw6t+9YpPYkmoq4/Quf/zO9J/1hdZJPEHv1BLHoFxafNoq6981HnMW/Pmmc/xpPiV05apiWclS6yQqWZmLCwiwf48MrNFrxqc98m5NeGQJbv8S9fqmgLlk/misbpl/ToeROnnp2tUfol7CuVJVrSaZe7rT0cZtaxA2AD7RN1x4OWZWMqdI4SXS2g1/4pk1p36cTfPm74XSov/zqtlsGpL9Mis8KmwbJFL/oLxurvQ6V8WDBUaki+l2T0CtEftYDJ5nijI+fE8Hi/o0TnZuHxJYD7x7W/lmorYDxbo/RLcPWLs/Sy9SePG6VpACge7RN1Z0ljg+WIWky1gGoPSz/JePf390MfOlED+G8nlJHQKxoaP1naEGV0tJjLd5U0Eo4ani+kUn+rv5fkxFFbxaFR+qWewX/z1EMjb1gmrjnC+iHlElHpP40F3R9x6U0+S8jcCwAFpcNf6CWDTAuEIOF8o3DZ8cLU2vH/WKSP/3sw8LCI+a4Qs9c64gWmGNRO2kdeN3nAqd1k9fCRrttpGgx50Ee1y7MK3T04XRN49QDRIN30tEed2HrqrVHb63Zv/N097iqbuN8LA0COyOLho86KuhrUcb/kCcQhO1HfAlbZUPyJ218mLM2hMFoRdQBsoPiiDracXIs6AMBHFqLewXXqAAAAsgaiDgAAFgFRBwAAi4CoAwCARUDUAQDAIiDqAABgERB1AACwCIg6AABYBEQdAAAsAqIOAAAWAVEHAACLgKgDAIBFQNQBAMAiIOoAAGAREHUAALAIiDoAAFgERB0AACyi5f98BAAAoD205d/ZpbkI6BxoOwCKg+NA49/ZAQAAUEDUAQDAIiDqAABgERB1AACwCIg6AABYBEQdAAAsAqIOAAAWAVEHAACLgKgDAIBFQNQBAMAi2vo1AZubm/T27Vt69+6dObK92LlzJ3V3d1NXV5c5svWg7QBIRqfGq1CIrwkQUdjY2NjWoiCfXepA6qJIoO3AdqSo47Vtoi5eHtAUrS7QdmA7U7T+3zZRh5dXo2h1gbYD25mi9X9MlAIAgEVA1AEAwCIg6gAAYBEQdQAAsAiIOgAAWAREHQAALAKiHos5mj98huburJh9AOxh7c6XNHuuSmtmX1ieOlN3LJQXVZo7/CUtvDD7oGNA1AEARI9v0POJedr9hzL1mEOx2F+m3so8vSrfoGVzCHQGiDoARYBFd5ajxOgthZcsXnalSl2TV2n4iDmWgNL4Vdo3WqXVVjz7tqIj7EzqqgBsC1FvOYQEIK8cGaPDs7fMJuLJxyqXPMe+oqH9+tS4LN+8QZujYzRwqt8cSUo/DU2MUdfMDVpKk6JUqZwzNP/Y7KdBlXWZ1j111aciCnuFPceivkIL57zWNXkuu3RWd7Tnh7MLDVX+0b03hJx+sms7TbC88AGpjHfUNZWny+1kBEO3mafcqTlzovbqRFCatrFblrPV35cuI3At2UKcDP/10tVZsKza5wvAn+HlNDVPuwQ+a6TgqjQM0ebEveRjwpSxXkk/f+UYrAPjI+aIE1GwsN+MqJOCk1tRX566RjTheCG8TZe5o1xI1sjcSUZmL9Fu4tAwi9Creo2eV4/TAXVveQ05O0embafE5AK9Ih6YTnmz54lueutbC/HqE8851TG+hwsBMVukl5M/Ua/pCy/PXaM35at0YHKYaPqRT4REUBq3MV9zkmjAvadGHqD0uwvqWvpcvr44GZ57E4P0fGKQ+pzyzP3HrzNtPHxlyfWmL4cbkocPaJPKtLdh2uUBLZUf0J6qLk/qa70SPY5KJ8r8s0qvU3japXF9Hek3kQapKXP0mg1WV/m3foP1+B69muHfgTa3hdyKemk8EE4eOalCzs3qjwnFc4SG1eCUgZcutNskHuzXHc+GQ072cogH6WoW4aIFZNl2rqfl1rfAdT5e21+7c5vWWZj6vOewIR9QYn3bIz7zROWTVDJ70o61lMMi/ewVKd81nTZ+QGvuOdyffPfEn1siQr7Gm4f1Qrx7+haNuNcaob3sidKTZV0fjrc8Pebem3P/sT1eJVjDtI+NgluW3Csb1vo+ukJrVa6TylHPuSGwAO6p1tq059RpNooNPN0jR/l9oo1n6bzsnlNfKYeAIgxSU14s0wb/2nWwllZSEQzXfZ+UG2xzSyhQTr2f3jtkXiaGB+d18ajShXZ1lr/0Pg/m9J3YXpK2XYSn5cMI0+j7Ski89Bw7rkT2rauKw7TnmCdvfKgUWW54G3vLCmF/iXaZl36GqTugmuKJHjZGIcpb7jk4yD/jCc/y/Sr/HKT3gvn1UKFdobcs2F0fNMmljx6nHl95/dQtOX3HKNWh3998msF4kLkENlDp06cmgnl6mqMNr8Gzj/yKel2+ksNrHuBZkirv5yVyMG9Tsmq7EE8rkgYCvVXGti5vLRNy5r04rD9lo6RSNN6yeKuIQCcgxMA5ZCK0mThYSeCIJpEjJuk5k/7y5NZtJZ+iLqJQ5rDbN7uvPex0aGstAiPhcGYWO4742E6WbWeMZVpR3op2EUFX67pVP3I2ydXHZ/cHw/yz7MmBe7fkq1rCaOqVt8QK/fyEfzUwpJkhE9zSnyQdxvVRS2G1gOk/65XLRL70F7ffs0X+GRLRWEAuRV2Ho8O072yWVlVba51vvJVqPW4Q536DIfZ2JHbbuV59WGhtwviGufh+6inXT3QKrU0Ctoa/LCflM0Z9GZSdJM0ShZqk9OX+DY8fcRQRSD8lTZO8+JHeNEzbtJjWaYLOf3O0Ig5CYP6iNczcRV07tTiXUFByKeq6k3snnGoediKUcEhoLN5Qtp6PlL3EHlvX5Plsyy0ocdtOi6UQtlqiNgntXSmiypyqTZzpibsqrXrPcdulNjGamLqyTPrBK55uH0uAmkiWCfw0OWODU9ZkYKWOEsfTgT4abRCj4bqf1J5z5Lp2ZUDSRUh6NZDUebqUibOc2btufnlKnDvWAktTMTt+YczrSLL4j/Tr6/G6uxPeOkiYu/c+i4MsW4tptaWDJPm7MFRZAYGSe4vr+e/enSRQj0/u207EUMJrZXAj0mHuOQ4SbQWNs0RiflH1tYuE8ZVF83fmXPEAeWDr+yX/e+bPHOrbWIyViIPZVfd/lF7z326wEDmhvr9sdSiSsL6lvNQ68THXPhT2nhC8N/aaPffkw9Ttrqg+rOotkNsPvacaqcdbs3uKS13/adDXImjneBXSjNncirrt2CzqxUaLuleYbUcbk/hCF0rWgpwTiiTq+ZwoBQC0Db2+PpC+SkQtNZPFXANIBkQdgO2OPHHNnro85JPmsXw3V51BmhMkB6IOAFAP+ajH8pM+sf1CnooNPskKOgFy6h0COXUAigNy6gAAADoCRB0AACyibaK+cyfsh0PR6gJtB7YzhRuv5veW093dbV6BotUF2g5sZ4rW/9sm6l1dXbRr165t7fXJZ5c6kLooEmg7sB0p6nht2+oX0BnQdgAUB6x+AQAA4AOiDgAAFgFRBwAAi4CoAwCARUDUAQDAIiDqAABgERB1AACwCIg6AABYBEQdAAAsAqIOAAAW0fLXBAAAAGgPab4moGVRHxgYMHugSCwtLaHtACgIMl4FfPcLAAAABUQdAAAsAqIOAAAWAVEHAACLgKgDAIBFQNQBAMAiIOoAAGAREHUAALAIiDoAAFgERB0AACyirV8TIJdq4XJWs2PHDrW1i6y+JgBtB7YjnRivQiG+JgCioCliPaDtwHaliH2/raIONEWrC7Qd2M5A1AEAAHQMiDoAAFgERB0AACwCog4AABYBUQcAAIuAqAMAgEVA1AEAwCIg6gAAYBEQ9VjM0fzhMzR3Z8XsA2APa3e+pNlzVVoz+8Ly1Jm6Y6G8qNLc4S9p4YXZBx0Dog4AIHp8g55PzNPuP5SpxxyKxf4y9Vbm6VX5Bi2bQ6AzQNQBKAIsurMcJUZvKbxk8bIrVeqavErDR8yxBJTGr9K+0SqttuLZtxUdYWdSVwVge4o6QkVQNI6M0eHZW2YT8eRjlUueY1/R0H59alyWb96gzdExGjjVb44kpZ+GJsaoa+YGLWWcolRpoKk5sxcDNdYv07qnrvpURGHv+M+xqK/Qwjmvdc0oly0eD4eIm6PHqSfhIBBU/tG9N4ScfrJuu2B54QNSDfyoaypPl9tJDXJ5X9rMU64rGNqrm3/cQhu7ZTlb/X3pMgLXki3Em/VfL12dBcuKFET+DC+nqXnaJfBZpX5CUWkYos2JexmNCV1vq3KPJ0bMsdZxDNaB8drf6oiChf1mAiNRAHIr6stT14gmHC+Et+kyd5QL6Ts6h5nKw7meMHcoVK/R8+pxOqDuLa8hZ+fItO2UmFygV8QD0ylv9jzRTW99ayFefeI5pzrG93AhIGaL9HLyJ+qdvUS7icXs3DV6U75KByaHiaYf+URovXKmSRvzNSeJBtx7auQB8t/yZ5Br6XP5+uzNPvfcmxik5xOD1OeUZ+4/fp1pEfSVJdebvhxuSB4+oE0q096GaZcHtFR+QHuqujypr/VKtKdbOlHmn1V6HSX8LSPtym0/M0z7+NrxU0Nz9JqNQVf5t/6x/vgel8m/A21uC7kV9dJ4IJw8clKFnJvVHxOJpx4089y5uWN6rHYSNokHu2sUOORkL4d4kK6m7sR2kGXbuZ6WzwhznY/X9tfu3KZ1FqY+7znsMQ4osb7tEZ95ovJJKpk9acdaymGRfvaKlO+aThs/oDX3nBEaDjgGpbNj1MXXePOwXoil34241xqhvezN0pNlXR+Otzw95t6bc/+xPV4lWCKCnrLkXtmw1vfRFVqrcp1UjnrODYEFcE+11qY9p06zUWzg6R45yu8TbTxL7oBpY36Z1qUdkqaWXizTBv/adbCWVtKOHVGf1EewzS2hQDn1fnrvkHkZCyd8S2rt66mz/KX3eTCn7MRWk7TtIjwtH0aYRt9XQuKl59hxJbJvXVUcpj3HPHnjQ6XIcsPb2FtWCPtLtMu89DNM3QHVLI2zc2GMQpS33HNwkH/GE57l+xyJ0iC9FxTBUKFdobcs2F0fNMml16Uq+6lbcvqOUapDv7/5NOF4cFKkaSNqHyaCeXqaow2vwbOP/Ip6IIcnm+TVYuOEWltJ5GDepmTVdiGeViQNBHqrjG1d3lo8S/NeHNafslFSKRpvWbxJqjAJIQbOIbHQ+khqpFuBxfe7hJ87Ep3GUemvlFF6EcinqIsoOJbazQtKztK8HwezakDnO7fowaE44mM7WbadMZZpRXkr2kUE3U3nuZ9TcvXx2f3BMP8se3Lg3i35qpYwmnrlLbFCPz/hXw0MaXL6aeg6f+7qGHXJPECaRQim/6xXLhP50l/cfs8W+WdIRGMBuRR1HY4O076z2VlVCXdlgkcm7BItjWqAc7/BEHs7ErvtXK8+bPCaML5hLr6fesr1E51Ca5OAreEvy0n5jFFfBmUnSbNEoSYpfbl/w+NHHEUE0k9J0yQvfqQ3DdM2LaZ1GrG/TCNmQns18fJjM3dR104tziUUlFyKuu7k3gmn2rKmNPSc+kqtxKCIlQCJYFFaYo+ta/J8ph5VUYnbdloshbDVErVJaO9KEVXmVK399MQdD37vOW671CZGE1NXlkk/eMVTGadk6Rc9kSyRZAqv1MEpazKwUket+jod6KPRBjEarvtJPXkdua5dGZAsIqQRGlYrj3SUHbmMsgFq8jqwbn55SlbUcGRkaSpmxy8t/FfVhYUFGhgYMHvJePfunXnVGk546yBh7t77LA6ybC3t5IkMQLVEK35oK6toggIl9xZ3AnbnzvbY06WlpXy3nWoLFgmVfoiYwHLPcZBJ72DbSd7UL6q+dpHJt8qi+TtzrqSIeGDr+yX/e+bPHOrbWIyViIPZVfd/lF7z325MXnVDfX/Z6lAkYX1LLb+tEx9z7UNh7wnBe2Ov2XNPPkzd7orqw6reAjnu0HuqoT5HFuPUgyqTGl83krr+06CvRdDO8SoMDQ2p30nIrajbjs2iXmy0qHuF2Xa0MYkvdKE0MxIFpUiinsv0CwCgfej19YH0VSJqqZks5hpAMiDqAGx3ZFKSPXWZa0qzOszNVWeYdgHxgagDANTSX7U6LOET25J2eake8LP7wZ4igJx6h0BOHYDigJw6AACAjgBRBwAAi2ibqO/YscO8AkWrC7Qd2M4Urf+3VdQhDsWsB7Qd2K4Ucry2a6IUdIYsJkoBAO0BE6UAAAB8QNQBAMAiIOoAAGAREHUAALAIiDoAAFgERB0AACwCog4AABYBUQcAAIuAqAMAgEVA1AEAwCJa/poAAAAA7aEt/3g6zUVA50DbAVAcHAca3/0CAABAAVEHAACLgKgDAIBFQNQBAMAiIOoAAGAREHUAALAIiDoAAFgERB0AACwCog4AABYBUQcAAIto69cEbG5u0tu3b+ndu3fmCAhj586d1N3dTV1dXeZIctB2AGwtWY9XoRBfEyCisLGxAVFoAakjqSupszyAtgMgmryN17aJunh5IB55qTO0HQDNycs4aZuow8uLT17qDG0HQHPyMk4wUQoAABYBUQcAAIuAqAMAgEVA1AEAwCIg6gAAYBEQdQAAsAiIOgAAWAREfSt4UaW5w2do/rHZB6AArN35kmbPVWnN7AvLU2fqjoWi+vyXtPDC7IOOAVEHABA9vkHPJ+Zp9x/K1GMOxWJ/mXor8/SqfIOWzSHQGSDqABQBFt1Zjv6itxResnjZlSp1TV6l4SPmWAJK41dp32iVVlvx7HOIilS8dTo1Z94pFttC1FsOIQHIK0fG6PDsLbOJePKxyiXPsa9oaL8+NS7LN2/Q5ugYDZzqN0eS0k9DE2PUNXODlu6smGMJ6ED6UjTi+QTRvqqpzyp/junLhRT2HIv6Ci2c81hN3uYSdpTSWd3Rnh9uf2ioDIrzGbaNYcmu7TTB8sK9Ul9dB6+pPF1ufyMY6rW3XHfwztE874ug+D23kL7jluVs9felywhcS7aQvhD0FNPUWcteJ3+Gl9PUPO0S+KyRgqvSMESbE/eSjzVTxnolbb9pEacOpj2Gke9hZLpMNH27cPMEuRX15alrRBOOF8IbV/DmxIVkjSwNNHuJdhOHhm2bzBmmje/O0Co53hRfXwxLQUO6OGTadkpMLtArGqMDTnmz54luekVRC/HqE8857GkRX9MvZov0cvIn6jV94eW5a/SmfJUOTA7z4H3kEyERlOfV46a8sLQCX3OSaMC9p1vUV5Gcclj/kn53QV1Ln1vfF7SnOEh9Tnnm/uPXmTYevrLkeuJ1hhmShw9ok8q0t2Ha5QEtlR/QHuPFSn2tV6LHUekEiyF/5tcpPO3SuL6O9Jut9pbD64Dr8bsq/56nNw/bYFgyJLeiXhoPhJNHTqqQc7P6Y0Jvd4SG1eCUgRf0NIKeYGBL5GHP0+YhFvTxEbM/Qn1KPIpn+eOSZds5qYED172eJIf547X9tTu3aZ0HZZ/3HDbkA3X1PU9UPkkls7dJxz0ph0X62dsuvmvy9diTpZkHtOaew/3Jd08mIowQgd3Tt2jEvdYI7WVPlJ4s6/pwPcUx996c+4/t8T6+R69mhmkfGwW3LLlX8TrZkKwG+v1aleukctRzbggzxIJea9OeU6fZKPI4uhkhtkeO8vtEG8/SiWHPqa+UQ0AhBqkuEvFt8Ry39adcB6Pvq3vWiJMgRviS7rdPIepbRD+9d8i8TAwPzuviUQVDO31cezUhW2DwtsruE46ga3oODvLPeXrb7hxQx0nadnP0msWuq/zbBvVvhMk3KDU9x44rka3V9zDtOebJGx8qRZZbd83S+4GyQthfol3mpZ9h6g6opniiTr+K8pZ1fwkYmyYs3xfvcpDeC+bXQ4V2hd6yYHd90CSXPnqcenzl9VO35PQdo1SHfj8TMZS5BMlvB9KnSvDDxqraks8v6DTdbermqKRmhItFfkU9kMOTbZUHeJakyvslQQnDNiCrtnuxTBv8a9fBFgZXA4FO6zFGUe8tXuaIIT7KU1QpGm9ZvFVEoBMQYuAcsvE6s3CwksARzRbm2NelPdnh60tjFHJAPkVdRKHMYbdvdl972OnQaRYRGAmHD886IepWpF9CWP6JPbJ6r80qsmw74/mmFeWWjEJMRNDVum7Vj5xNcvXx2f3BMP8se3Lg3i1bgWnqlbfECv38hH81MKSZIZ6z9CdJh3F9ON5zlukXVf+SmlJzKN60VYuRTM7IpajrcHSY9p31py/SofNkOt94K7Aed2vSL0EiQ2OLiN12rlcfsrrECeMb5uL7qadcP9EptDYJ2Br+spyUzxj1ZVB2kjRLFGqS0pf7Nzx+xFFEIP2UNE3y4kd601DsshFDJdwSrYiDEBiDWaZfdJqOxT24Aii0zvJPLkXdyT3XJpxqHnYilHBIaCzeUIdCK/Y4dITg9QTsI27babEUwlZLOBOUwVVDXOZULXrSE3dVWvWew22+xJ5012RtYjQxdWWZ9INXPN0+lgA1kZzR05hOWZPe6JIdGiWOpwN9P9ogRsN1P9lkXbsSw3QRkl4NJHV+1bPYYItwl1B66l/aUz2Qdb5wqZgdvzDmdSQLCws0NDRk9pKxvh6vuzvhrYOEuXvvszjIsrWYnrN0kCR/lxwRMokKzK5CIoT4BmX37iQBfY3ct50MHgmvlcGNMHjuOQ5hdSmRmF9U5bpuRCZhfGXR/J05VzxAFgx9v/Lgiec982cOvrIUwTaW+z9Kr/lvN1iIvGmCWtnqUCSqnwaNn7lHP+bavtVVXur7n4hj6MSfqdtddZ/PoOotkNsPvacaqcdbs3vaIoL1H1lnDchivAppxmxuRR1oiijqxUaLuleYbUeLWQOjGocOCXJeyIOo53f1CwCgLej19YH0VSJqqZks5hpAMiDqAGx33EfiL6d6LH95SlI+7PG3Lc0JwoCoAwDUQz7qsfykT2y/kKdiZa7D7oUARQA59ZyDnDoAxQE5dQAAAJkCUQcAAItom6jv3An7EZe81BnaDoDm5Ga8mt9bTnd3t3kFWiUvdYa2A6A5eRknbRP1rq4u2rVrF7y+FpA6krqSOssDaDsAosnbeG3b6hfQGdB2ABQHrH4BAADgA6IOAAAWAVEHAACLgKgDAIBFQNQBAMAiIOoAAGAREHUAALAIiDoAAFgERB0AACyi5SdKAQAAtIc0T5S2LOoDAwNmDxSJpaUltB0ABUHGq4CvCQAAAKCAqAMAgEVA1AEAwCIg6gAAYBEQdQAAsAiIOgAAWAREHQAALAKiDgAAFgFRBwAAi4CoAwCARbT1awLkUi1cDjA7duxQW1qy+poAtB0A0WQ5XoVCfE0ARCEeeaovtB0AjcnTGGmrqIN45KXO0HYANGfbiToAAICtB6IOAAAWAVEHAACLgKgDAIBFQNQBAMAiIOoAAGAREHUAALAIiDoAAFgERH0reFGlucNnaP6x2QegAKzd+ZJmz1VpzewLy1Nn6o6Fovr8l7TwwuyDjgFRBwAQPb5BzyfmafcfytRjDsVif5l6K/P0qnyDls0h0Bkg6gAUARbdWY7+orcUXrJ42ZUqdU1epeEj5lgCSuNXad9olVZb8exziIpUvHU6NWfeKRbbU9QRKoKicWSMDs/eMpuIJx+rXPIc+4qG9utT47J88wZtjo7RwKl+cyQp/TQ0MUZdMzdo6c6KOZYNKg20hSIr5T+fINpXNfVZ5c8xfbmQwp5jUV+hhXMeq8nbXBYdRTweDhE3R49TT8JBEAfVGZ3PUFAPJj5Zt12wvHCD7Kvr4DWVp3uDls18h3rtLdcdvHM0z/syH+L33ELSCm5ZzlZ/X7qMwLVkC+kLQU8xTZ217HXyZ3g5Tc3TLoHPGjlfpNIwRJsT9zJKw+h6W5V7PDFijmWMUwfTHsPIn2Nkukw0fbtwzl9uRX156hrRhOOF8MYVvDlxIX1H5zBTeTjXE+YOW2aYNr7jzkiON3WJdrMH87ygIV0cMm07JSYX6BWN0QGnvNnzRDe9oqiFePWJ5xz2tIiv6RezRXo5+RP1SlsQD+Rz1+hN+SodmBzmwfvIJ0LrFfbcqsdNeWFpBb7mJNGAe0+3qK8iOeUwg8N/y59BrqXPre8L2lMcpD6nPHP/8etMi6CvLLmeeJ1hhuThA9qkMu1tmHZ5QEvlB7THeLFSX+uV6Ei3dILFkD/z69QLBaRdue1nhpUHnSY11IjwOuB6/I61gubpzcPkmtMJcivqpfFAOHnkpAo5N6s/JvJ29aCZ587NHXM8aPEDXlRwS+Rhz9PmIRZ091oj1KfEo3iWPy5Ztp2TGjjgM8Ic5o/X9tfu3KZ1HpR93nPY0xqoq+95ovJJKpm9TTruSTks0s/edvFdk6/HnizNPKA195wRGg44BqWzHLJHiID0uxH3WiO0l71ZerKs68P1FMfce3PuP7bH+/ieEUFPWXKv4nWyIVn1Ce0KrVW5TipHPeeGMEMs6LU27Tl1mo0iG7CbEQ7KkaP8PtHGsxRiqIz5ZVqXdghJLdVFIr4tXmp1/SnXwej76p412pi8KV/S/fYpRH2L6Kf3DpmXsXDCt0bWngftdcerCdkSevXBcLHn4CD/nKe32255QNK2m6PXLHZd5d82qH8jTL5Bqek5dlyJbK2+h2nPMU/e+FApsty6a5beD5QVwv4S7TIv/QxTd0A1S+O1fhXlLev+EjA2TVi+L97lIL0XEMFwoV2htyzYXR80yaXXpSr7qVty+o5RqkO/n1gMnRRpg4i659RX4WNVbfVGoGVUmu42dbNW1IxwscivqAdyeLJJXi02ynMxrzuNEoZtQFZt92KZNvjXroMtDK4GAp3KY2xAvbfInqV5Lw7KU1QpGm9ZvEmqMAkhBs4hG68zqZFuBSft0X7WVXqWqC+NUcgB+RR1EQXHUnsscJ+ErHExqwZ0vjNq8mkr0i8hLP/EHlm912YVWbad8XzTinJLRiEmIuhuOs/9nJKrj8/uD4b5Z9mTA/du2QpMU6+8JVbo5yf8q4EhTY6Jmp3VJ2ET1EyW6RdV/5KaUnMo3rRVi5FMzsilqOtwdJj2nc1utlvCXZngkQm7+pUAW5N+CRIZGltE7LZzvfqwwWvC+Ia5+H7qKddPdAqtTQK2hr8sJ+UzRn0ZlJ0kzRKFmqT05f4Njx9xFBFIPzn1G9d7f/EjvWkodhmIoaw+MRPaqyEinWX6RafpWNyDK4BC6yz/5FLUndxzbcLJyYub3YSojqCWKYWvBNhSHrMnEJwMs5C4bafFUghbLeFMUAZXDXGZU7X20xN3PPi957CxWGJPumuyNjGamLqyTPrBK57KOCVLv+iJ5IyexnTKmvT27zmaV6u+TgfELtogRsN1P6knryPXtSsxzCJCGqFhtfJIR9lb9rUbZhnmesVT/9Ke6oGs84VLxez4pYX/lrqwsEADAwNmLxnv3r0zr1rDCW8dJMzde5/FQZatpfWcpcHUEq2typ2JkMlSLLOrkIna+NfbuTOd3V1aWsp326m2YJFQ6YcIg+ee4xBWl7JiwS+qcl13YlwmwCqL5u/MuZIiGh8x9ysPnnjeM3/m4CtLEWxjuf+j9Jr/dmPyqjvJ5i9bHYpEVmjVGT9zj37MtX2rq7zU9z95WjR04s/U7a66z2dQ9RbIcYfeUw31ObIYpx5UmbI8uMF10xKs/8g6a0AW41UYGhpSv5OQW1EHmiKKerHRou4VZtvRYtbAqMahmZGwnDyIei7TLwCA9qHX1wfSV4mopWaymGsAyYCoA7DdcR+Jv5zqie3lKUn5BB4CA20Hog4AUEt/1eqwhE9sS9rlpXrAz+6FAEUAOfWcg5w6AMUBOXUAAACZAlEHAACLgKgDAIBFtE3Ud+zYYV6BVslLnaHtAGhOXsZJW0Ud4tA6eaovtB0AjcnVeG3X6hfQGbJY/QIAaA9Y/QIAAMAHRB0AACwCog4AABYBUQcAAIuAqAMAgEVA1AEAwCIg6gAAYBEQdQAAsAiIOgAAWETLT5QCAABoD3iiFAAAgKIlTx0AAEAxgKcOAAAWAVEHAACLgKgDAIBFQNQBAMAiIOoAAGAREHUAALAIiDoAAFgD0f8Dh8odf9exfNQAAAAASUVORK5CYII=)
所有的比较都转换为对 compareTo 的调用,这个函数需要返回 Int 值
用infix函数自定义中缀操作符
我们可以通过自定义infix函数来实现中缀操作符。
代码示例
data class Person(val name: String, val age: Int)
infix fun Person.grow(years: Int): Person {
return Person(name, age + years)
}
测试代码
package com.easy.kotlin
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
@RunWith(JUnit4::class)
class InfixFunctionDemoTest {
@Test fun testInfixFuntion() {
val person = Person("Jack", 20)
println(person.grow(2))
println(person grow 2)
}
}
输出
Person(name=Jack, age=22)
Person(name=Jack, age=22)