kotlin基础——重载
重载算术运算符
重载二元算术运算
使用operator定义plus()方法后，可以直接使用+号求和
data class Point(val x: Int, val y: Int) {
operator fun plus(other: Point): Point {
return Point(x + other.x, y + other.y)
}
}
val p1 = Point(1, 2)
val p2 = Point(3, 4)
print(p1 + p2)
若定义为扩展函数，也可实现
data class Point(val x: Int, val y: Int)
operator fun Point.plus(other: Point): Point {
return Point(x + other.x, y + other.y)
}
可供选择的重载运算有如下，不会自动支持交换性
不要求两个运算数是相同类型
data class Point(val x: Int, val y: Int)
operator fun Point.times(scale: Double): Point {
return Point((x * scale).toInt(), (y * scale).toInt())
}
val p = Point(10, 20)
println(p * 1.5)
返回类型也可不同于任一运算数类型
operator fun Char.times(count: Int): String {
return toString().repeat(count)
}
println('a' * 3)
Kotlin中的位运算符如下
- shl一一带符号左移
- shr一一带符号右移
- ushr一一无符号右移
- and一一与
- or 一一或
- xor一一异或
- inv一一取反
println(0x0F and 0xF0)
println(0x0F or 0xF0)
重载复合赋值运算符
可通过定义plusAssign()重写+=
data class Point(var x: Int, var y: Int)
operator fun Point.plusAssign(other: Point): Unit {
x += other.x
y += other.y
}
val p = Point(1, 2)
p += Point(3, 4)
println(p)
系统自带函数库已经重写了该方法，将一个元素添加到可变集合
val number = ArrayList()
number += 1
number += 2
for (i in number) {
println(i)
}
当使用+=时，plus()和plusAssign()都可能被调用，解决办法是
- 替换运算符为普通函数调用
- 用val代替var修饰变量，这样不能调用plusAssign()
- 若类是不可变的，则提供plus()即可，若类是可变的则提供plusAssign()
重载一元运算符
如下获取负坐标
data class Point(var x: Int, var y: Int)
operator fun Point.unaryMinus(): Point {
return Point(-x, -y)
}
val p = Point(1, 2)
println(-p)
可重载的一元运算符有
重载比较运算符
等号运算符：equals
在Kotlin中使用==会被转换成equals，其可用于可空类型
a == b
相当于
a?.equal(b) ?: (b == null)
equals在Any类中且已经标记为operator，所以只需要用override复写，不能实现为扩展函数，因为继承自Any类的实现始终优先于扩展函数
class Point(var x: Int, var y: Int){
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as Point
if (x != other.x) return false
if (y != other.y) return false
return true
}
override fun hashCode(): Int {
var result = x
result = 31 * result + y
return result
}
}
排序运算符：compateTo
比较运算符 （<、> 、<= 和 >=）将转换成compateTo，Java中实现了Comparable的类在Kotlin中都可以使用运算符
class Person(val name: String, val age: Int) : Comparable {
override fun compareTo(other: Person): Int {
return compareValuesBy(this, other, Person::age, Person::name)
}
}
val p1 = Person("A",1)
val p2 = Person("B",1)
println(p1 < p2)
如上按照字母表顺序比较，p1 < p2等价于p1.compateTo(p2) < 0，
集合和区间
下标运算符访问元素：get和set
data class Point(var x: Int, var y: Int)
operator fun Point.get(index: Int): Int {
return when (index) {
0 -> x
1 -> y
else -> throw IndexOutOfBoundsException("Invalid coordinate")
}
}
operator fun Point.set(index: Int, value: Int) {
when (index) {
0 -> x = value
1 -> y = value
else -> throw IndexOutOfBoundsException("Invalid coordinate")
}
}
val p = Point(1, 2)
println(p[0])
p[0] = 3
println(p[0])
in和contains
如下重写contains，使用in判断点是否在矩形中
data class Point(var x: Int, var y: Int)
data class Rectangle(val upperLeft: Point, val lowerRight: Point)
operator fun Rectangle.contains(p: Point): Boolean {
return p.x in upperLeft.x until lowerRight.x
&& p.y in upperLeft.y until lowerRight.y
}
val rect = Rectangle(Point(10, 20), Point(50, 50))
println(Point(20, 30) in rect)
…和rangeTo
使用1…10创建一个[1,10]的区间，可通过rangeTo为类定义该运算符，其是Comparable的扩展函数，若一个类实现了Comparable可直接使用rangeTo
val now = LocalDate.now()
val vacation = now..now.plusDays(10)
println(now.plusWeeks(1) in vacation)
rangeTo优先级低于算术运算符，使用时最好使用括号
val n = 9
println(0..(n + 1))
(0..n).forEach { println(it) }
for和iterator
在for中使用in会调用iterator方法，如遍历String，其父类CharSequence已经实现了iterator
for (c in "abc") {
println(c)
}
如下在LocalDate的闭区间上定义iterator
operator fun ClosedRange.iterator(): Iterator =
object : Iterator {
var current = start
override fun hasNext() =
current <= endInclusive
override fun next() = current.apply {
current = plusDays(1)
}
}
val newYear = LocalDate.ofYearDay(2017, 1)
val dayOff = newYear.minusDays(1)..newYear
for (day in dayOff) {
println(day)
}
解构声明
解构声明允许展开单个复合值，并使用它来初始化多个单独的变量，如下
data class Point(var x: Int, var y: Int)
val p = Point(10, 20)
val (x, y) = p
println(x)
println(y)
解构声明初始化变量，相当于调用名为ComponentN的函数，N是声明中变量的位置，如下
class Point(var x: Int, var y: Int) {
operator fun component1() = x
operator fun component2() = y
}
解构声明主要用于展开函数返回的数据类，如下将文件和扩展名分割
data class NameComponents(val name: String, val extension: String)
fun splitFilename(fullName: String): NameComponents {
val result = fullName.split(".", limit = 2)
return NameComponents(result[0], result[1])
}
val (name, ext) = splitFilename("demo.kt")
println(name)
println(ext)
解构声明可以在数组和集合上使用，修改上面的splitFilename方法
fun splitFilename(fullName: String): NameComponents {
val (name, ext) = fullName.split(".", limit = 2)
return NameComponents(name, ext)
}
解构声明可用于循环中的变量声明，如遍历map
fun printEntries(map: Map) {
for ((key, value) in map) {
println("$key -> $value")
}
}
val map = mapOf("1" to "A", "2" to "B")
printEntries(map)
委托
by lazy
惰性初始化直到第一次访问该属性时才创建对象，常规的做法如下
class Email()
fun loadEmails(person: Person): List {
Thread.sleep(5000)
return listOf(Email(), Email())
}
对于上述加载耗时的操作，使用_emails来存储，而另一个email用于返回
class Person(val name: String) {
private var _emails: List? = null
val email: List
get() {
if (_emails == null) {
_emails = loadEmails(this)
}
return _emails!!
}
}
上面代码繁琐且非线程安全，使用by lazy可以让代码简单
class Person(val name: String) {
val email by lazy { loadEmails(this) }
}
实现委托
实现一个例子，当对象改变时通知监听器，Java通过PropertyChangeSupport和PropertyChangeListener实现
open class PropertyChangeAware {
protected val changeSupport = PropertyChangeSupport(this)
fun addPropertyChangeListener(listener: PropertyChangeListener) {
changeSupport.addPropertyChangeListener(listener)
}
fun removePropertyChangeListener(listener: PropertyChangeListener) {
changeSupport.removePropertyChangeListener(listener)
}
}
Person继承上面的PropertyChangeAware，在setter时通知listener
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
var age: Int = age
set(newValue) {
val oldValue = field
field = newValue
changeSupport.firePropertyChange("age", oldValue, newValue)
}
var salary: Int = salary
set(newValue) {
val oldValue = field
field = newValue
changeSupport.firePropertyChange("salary", oldValue, newValue)
}
}
Person添加listener，属性改变时响应
val p = Person("Tom", 20, 1000)
p.addPropertyChangeListener(
PropertyChangeListener { event ->
println(
"Property ${event.propertyName} change" +
"from ${event.oldValue} to ${event.newValue}"
)
}
)
p.age = 21
可以优化代码，将属性变化的值过程封装到ObservableProperty
class ObservableProperty(
val proName: String,
var propValue: Int,
val changeSupport: PropertyChangeSupport
) {
fun getValue(): Int = propValue
fun setValue(newValue: Int) {
val oldValue = propValue
propValue = newValue
changeSupport.firePropertyChange(proName, oldValue, newValue)
}
}
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
val _age = ObservableProperty("age", age, changeSupport)
var age: Int
get() = _age.getValue()
set(value) = _age.setValue(value)
val _salary = ObservableProperty("age", age, changeSupport)
var salary: Int
get() = _salary.getValue()
set(value) = _salary.setValue(value)
}
Kotlin中委托的原理也是如此，将属性的getter和setter委托给ObservableProperty，不同的是
- setter和getter标记为operator，一个参数接受对象实例，用于读写属性，另一个用于表示属性本身，类型为KProperty
- 使用by代替之前代码中调用setter和getter的步骤
class ObservableProperty(
var propValue: Int,
val changeSupport: PropertyChangeSupport
) {
operator fun getValue(p: Person, prop: KProperty<*>): Int = propValue
operator fun setValue(p: Person, prop: KProperty<*>, newValue: Int) {
val oldValue = propValue
propValue = newValue
changeSupport.firePropertyChange(prop.name, oldValue, newValue)
}
}
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
var age: Int by ObservableProperty(age, changeSupport)
var salary: Int by ObservableProperty(salary, changeSupport)
}
最后，Kotlin自带了Delegates.observable，代替我们写的ObservableProperty类，只需要传递一个Lambda通知属性值的修改
class Person(val name: String, age: Int, salary: Int) : PropertyChangeAware() {
private val observer = { prop: KProperty<*>, oldValue: Int, newValues: Int ->
changeSupport.firePropertyChange(prop.name, oldValue, newValues)
}
var age: Int by Delegates.observable(age, observer)
var salary: Int by Delegates.observable(salary, observer)
}
