Kotlin for Java Developers 学习笔记
From Java to Kotlin
Java 和 Kotlin 代码可以相互转化
public class Person {
private final String name;
private final int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
class Person(val name: String, val age: Int)
Kotlin 被编译为 Java 字节码，所以从 Java 代码的层面看，这两者是一样的，都有一个 Constructor 和两个 Getter
也可以加上 data 修饰符，表示自动生成 equals、hashCode 和 toString 这三个函数
data class Person(val name: String, val age: Int)
多个变量可以以 Pair 的形式赋值
val (description: String, color: Color) = Pair("hot", RED)
如果数据的类型在上下文中可以很明确地被推导出来，那么可以不用声明变量的类型
val (description: String, color: Color)
val (description, color)
多于 2 个 if … else … 时可以使用 when 关键字，类似于 switch，但又有细微区别
val (description, color) = when {
degrees < 10 -> Pair("cold", BLUE)
degrees < 25 -> Pair("mild", ORANGE)
else -> Pair("hot", RED)
}
基本语法
Kotlin 的代码也是从 main 函数开始
package intro
fun main() {
val name = "Kotlin"
println("Hello, $name!")
}
从 Kotlin 1.3 开始
fun main(args: Array<String>)
可以只写
fun main()
变量、常量与字符串模板
字符串模板 $variable，${args.getOrNull(0)}
“变量”分为 val 和 var，val 是只读的
Kotlin 是静态类型的语言，每一个变量都会有自己的类型，但是我们可以在代码中省略基本类型，编译器会自动推断
var s = "abc" // var s: String = "abc"
var v = 123 // var v: Int = 123
我们不能给一个类型的变量赋值另一个类型的数据，例如：字符串常量赋值给一个 Int 类型的变量 string，这是一个编译时错误
var string = 1
string = "abc" // NOT ALLOWED是不允许的，我们不能把
val 不对数据做任何强加的限制，仍然可以改变其引用的数据，例如通过 list.add() 去修改一个被 val 修饰的列表，只要这个列表本身是允许被修改的
val list = mutableListOf("Java") // list.add() 可以往 List 中加东西
val list = listOf("Java") // list.add() 是不存在的
函数
fun max(a: Int, b: Int): Int {
return if (a > b) a else b
}
如果只有一句话（function wilth expression body），可以写成
fun max(a: Int, b: Int) = if (a > b) a else b
void 类型的函数在 Kotlin 中会以 Unit 的形式返回
Kotlin 的函数可以定义在任何地方：顶层、类的成员、函数中定义另一个函数
调用顶层函数相当于 Java 中的 static 函数
// MyFile.kt
package intro
fun foo() = 0
//UsingFoo.java
package other;
import intro.MyFileKt;
public class UsingFoo {
public static void main(String[] args) {
MyFileKt.foo();
}
}
为变量提供默认值，不再需要重载各种函数
fun displaySeparatpr(character: Char = '*', size: Int = 10) {
repeat(size) {
print(character)
}
}
displaySeparator() // **********
displaySeparator(size = 5) // *****
displaySeparator(3, '5') // WON'T COMPILE
displaySeparator(size = 3, character = '5') // 555
分支
在 Kotlin 中，if 是表达式
val max = if (a > b) a else b
没有三元表达式
(a > b) ? a : b
注意与 Python 的区别
max = a if a > b else b
在 Kotlin 中，when 可以当作 switch 使用，不需要 break
switch (color) {
case BLUE:
System.out.println("cold")
break;
case ORANGE:
System.out.println("mild")
break;
default:
System.out.println("hot")
}
when (color) {
BLUE -> println("cold")
ORANGE -> println("mild")
else -> println("hot")
}
可以使用任何类型，可以用来判断多个条件
fun response(input: String) = when (input) {
"y", "yes" -> "Agree"
"n", "no" -> "Sorry"
else -> "Not Understand"
}
可以做类型检查
if (pet instanceof Cat) {
((Cat) pet).meow();
} else if (pet instanceof Dog) {
Dog dog = (Dog) pet;
dog.woof();
}
when (pet) {
is Cat -> pet.meow()
is Dog -> pet.woof()
}
可以不需要参数
fun updateWeather(degrees: Int) {
val (desc, color) = when {
degrees < 5 -> "cold" to BLUE
degrees < 23 -> "mild" to ORANGE
else -> "hot" to RED
}
}
循环
val map = mapOf(1 to "one", 2 to "two", 3 to "three")
for ((key, value) in map) {
println("$key = $value")
}
val list = listOf("a", "b", "c")
for ((index, element) in list.withIndex()) {
println("$index: $element")
}
for (i in 1..9) // 1 2 3 4 5 6 7 8 9
for (i in 1 until 9) // 1 2 3 4 5 6 7 8
for (ch in "abc")
for (i in 9 downTo 1 step 2) // 9 7 5 3 1
拓展函数
fun String.lastChar() = get(length - 1)
val c: Char = "abc".lastChar()
也可以直接在 Java 中使用 Kotlin 中定义的拓展函数
import lastChar from ExtensionFunctions.kt;
char c = lastChar("abc");
常用的有 withIndex、getOrNull、joinToString、until、to 、eq、toInt 等等
val set = hashSetOf(1, 7, 53)
println(set.javaClass) // class java.util.HashSet
fun main(args: Array<String>) {
println("Hello, ${args.getOrNull(0)}!")
}
val regex = """\d{2}\.\d{2}\.\d{4}""".toRegex()
regex.matches("15.02.2016") // true
regex.matches("15.02.16") // false
特别的，until 和 to 这种，本身是需要通过 . 和 () 调用的
1.until(10)
"Answer".to(42)
但是因为原型声明的时候允许 infix
infix fun Int.until(to: Int) = IntRange
infix fun <A, B> A.to(that: B) = pair(this, that)
所以可以省略 . 和 ()
1 until 10
"Answer" to 42
成员函数比拓展函数的优先级高，例如下例会输出 1，并得到一个警告，说 entension is shadowed by a member
class A {
fun foo() = 1
}
fun A.foo() = 2 // Warning: Extension is shadowed by a member
A().foo() // 1
但是我们可以重载一个拓展函数
class A {
fun foo() = "member"
}
fun A.foo(i: Int) = "extension($i)"
A().foo(2) // extension(2)
标准库
Kotlin 的标准库包括 Java 标准库和一些常用的拓展函数
没有所谓的 Kotlin SDK，只有 Java 的 JDK 和一些 extensions
Nullability
现代的编程语言应该把 Null Pointer Exception 变成编译时错误，而不是运行时错误
val s1: String = "always not null" // 不可以 = null
val s2: String? = null // 或者 = "a string"
对于一个可能为 null 的变量，我们应该始终用 if 语句检查
if (s != null) {
s.length
}
在 Kotlin 中。可以使用 ? 来简化访问，如果对象为 null，则运行结果为 null，返回类型是 nullable 的基本类型
val length: Int? = s?.length
如果只想要基本类型，可以使用 elvis 运算符（ elvis 来自 Groove）
val length: Int = s?.length ?: 0
可以使用 !! 强制抛出 NPE
elvis 的优先级比加减法低
val x: Int? = 1
val y: Int = 2
val z1 = x ?: 0 + y // 1
val z2 = x ?: (0 + y) // 1
val z3 = (x ?: 0) + y // 3
? 的位置不同会决定具体什么东西不可以为 null：List<Int?> 和 List<Int>?
Kotlin 中使用 as 进行类型转换，同样可以对 as 进行 ? 修饰
if (any is String) {
any.toUpperCase()
}
(any as? String)?.toUpperCase()
函数式编程
Lambda
与匿名类类似，在现代语言（例如 Kotlin）和 Java 8 中，都支持了 Lambda 使得语法更简单
Kotlin 中的 Lambda 用 {} 包围，为了与正则表达式区分，Lambda 的 {} 常加粗
list.any({i: Int -> i > 0})
当 Lambda 是括号中最后一个参数时，我们可以把 Lambda 从括号中移出
当括号为空时，可以省略空括号
当类型可以被推断时，可以省略类型
当只有一个参数时，可以只用
it而无需声明参数
于是可以简化为
list.any { it > 0 }
多行的 Lambda 的最后一个表达式为 Lambda 结果
list.any {
println("processing $it")
it > 0
}
可以使用解构声明简化 Lambda 表达式
对于没有使用的参数，可以用 _ 替代
map.mapValues {entry -> "${entry.key} -> ${entry.value}!" }
map.mapValues {(key, value) -> "${key} -> ${value}!" }
map.mapValues {(_, value) -> "${value}!" }
常用的集合操作
- filter 只保留满足谓词条件的元素
- map 将每一个元素按指定规则变换
- any 判断列表中是否有满足谓词条件的元素
- all 判断列表中是否所有元素都满足谓词条件
- find 找第一个满足谓词条件的元素，如果不存在则为 null，等价于将谓词条件作为参数的 first 或者 firstOrNull
- count 计算列表中满足谓词条件的元素个数
- partition 按是否满足谓词条件，将列表分裂为 2 个列表
- groupBy 按照指定字段将元素分类为若干个列表（例如按照 it.age 分类）
- associatedBy 会将重复字段删除
- zip 将 2 个列表合并为一个列表，其中每一个元素分别由两个列表各自对应位置元素组合，如果列表长度不同，则合并后的元素个数是较短列表的长度，其余部分将被忽略
- flatten 将嵌套的列表展开
- flatMap 是 map 和 flatten 的组合
- distinct 保留列表中互不相同的元素
- maxBy 查找列表中给定字段最大的元素，如果列表为空则返回 null
组合这些操作，我们可以很容易进行复杂的运算，例如找年龄的众数
val mapByAge: Map<Int, List<Hero>> = heros.groupBy {it.age }
val (age, group) = mapByAge.maxBy { (_, group) -> group.size }!!
println(age) // 找众数
函数类型
Lambda 表达式是有函数类型的
val isEven: (Int) -> Boolean = { i: Int -> i % 2 == 0 }
val result: Boolean = isEven(2) // true
对于没有参数的函数，使用 () 调用看起来很奇怪，所以经常使用 run
{ println("hey!") }() // possible, but looks strange
run { println("hey!") }
() -> Int? 表示返回值可以为 null，而 (() -> Int)? 表示表达式可以为 null
成员引用
可以往变量中存储 Lambda 表达式，但是不可以存储一个函数，在 Kotlin 中，函数和 Lambda 是两回事，如果一定要把函数保存到变量中，可以使用函数引用
val isEven: (Int) -> Boolean = { i % 2 == 0 } // OK
fun isEven(i: Int): Boolean = i % 2 == 0
val predicate = isEven // COMPILE ERROR
fun isEven(i: Int): Boolean = i % 2 == 0
val predicate = ::isEven // OK
list.any(::isEven) // OK
可以将函数绑定到特定的实例，也可以不绑定
class Person(val name: String, val age: Int) {
fun isOlder(ageLimit: Int) = age > ageLimit
}
val alice = Person("alice", 29)
val agePredicate = alice::isOlder
agePredicate(21) // true
val agePredicate: (Person, Int) -> Boolean = { person, ageLimit -> person.isOlder(ageLimit) }
agePredicate(alice, 21) // true
下面这个例子是 Bound Reference，Person 被存储在了实例的内部，所以函数类型是 (Int) -> Boolean 而不是 (Person, Int) -> Boolean
class Person(val name: String, val age: Int) {
fun isOlder(ageLimit: Int) = age > ageLimit
fun getAgePredicate() = ::isOlder // this::isOlder
}
函数返回值
return 只会返回到函数 fun，而不会到返回 Lambda
fun containsZero(list: List<Int>): Boolean {
list.forEach {
if (it == 0) return true
}
return false
}
// 这个 forEach 接受了一个 Lambda 表达式，但是 return 是返回到 fun containsZero 的
fun duplicateNonZero(list: List<Int>): List<Int> {
return list.flatMap {
if (it == 0) return listOf()
listOf(it, it)
}
}
duplicateNonZero(listOf(3, 0, 5)) // 输出 []
// 因为 return 只会返回到 fun duplicateNonZero，而不是先返回给 flatMap 接受的 Lambda 再经由 flatMap 返回
为了避免这种情况，我们应该避免使用 return 语句，利用 Lambda 将最后一行作为返回值的特性来实现 Lambda 中的返回
fun duplicateNonZero(list: List<Int>): List<Int> {
return list.flatMap {
if (it == 0) {
listOf()
} else {
listOf(it, it)
}
}
}
如果确实需要将结果返回到 Lambda，可以使用 return@ 返回到指定的标签
list.flatMap {
if (it == 0) return@flatMap listOf<Int>()
listOf(it, it)
}
list.flatMap l@ { // 自定义标签 l
if (it == 0) return@l listOf<Int>()
listOf(it, it)
}
另外的解决方案是使用本地函数或者匿名函数
fun duplicateNonZeroLocalFunction(list: List<Int>): List<Int> {
fun duplicateNonZeroElement(e: Int): List<Int> {
if (e == 0) return listOf()
return listOf(e, e)
}
return list.flatMap(::duplicateNonZeroElement)
}
fun duplicateNonZero(list: List<Int>): List<Int> {
return list.flatMap(fun (e): List<Int> {
if (e == 0) return listOf()
return listOf(e, e)
})
}
forEach 中的 return 不会像 break 一样响应
fun foo(list: List<Int>) {
list.forEach {
if (it == 0) return
print(it)
}
print("##") // 如果 list 包含 0，则不会输出 ##
}
fun bar(list: List<Int>) {
for (element in list) {
if (element == 0) break
print(element)
}
print("##") // 始终会输出 ##
}
属性
属性和域成员变量
在 Kotlin 中，依然保持了 Java 中属性的概念，但是不再需要显式地声明 getter 和 setter
- property = field + accessor
- val = field + getter
- var = filed + getter + setter
例如在 Kotlin 的这段代码中，如果将它转化为 Java 代码，则隐含了 3 个 accessor
class Person (val name: String, var age: Int)
// String getName()
// int getAge()
// void setAge(int newAge)
对属性的访问
下面这段代码中，“Calculati……” 会输出 3 次
对于 foo1 来说：
代码中使用了 run，所以运行了 Lambda 并且把最后一行的表达式作为了结果，因此 foo1 获得了值 42，并在这个过程中输出了 “Calculating……” 的信息
Lambda 表达式的值只在赋值时被计算一次，之后就会使用 property 的值，所以 “Calculating……” 只会输出 1 次
对于 foo2 来说：
- 我们写了一个自定义的 getter，所以当访问 foo2 时，会访问自定义的 getter，因此输出 2 次 “Calculating……”
val foo1 = run {
println("Calculating the answer...")
42
}
val foo2: Int
get() {
println("Calculating the answer...")
return 42
}
fun main(args: Array<String>) {
println("$foo1 $foo1 $foo2 $foo2")
}
class StateLogger {
var state = false
set(value) {
println("state has changed: $field -> $value")
field = value
}
}
StateLogger.state = true // state has changed: false -> true
在 accessor（getter 和 setter）中，我们可以使用 field 来访问域成员变量，但是也仅能在 accessor 中通过这种方式来访问
如果重新定义了 accessor 但是没有使用 field，编译器会忽略并且不会生成对应的 accessor
如果没有为属性定义 accessor，那么会有默认的 getter 和 setter
在类的内部，className.valueNale 的代码将由编译器决定是否对齐进行优化，如果访问非常简单，那么编译器会替换为直接访问这个变量本身，注意这样的优化对于类外部的访问来说是不安全的，所以在类的外部，className.valueNale 会调用对应的 getter 作为字节码，而不是直接访问这个变量本身
使用 private set 来将一个成员变量设置为仅允许从内部被修改，而不会被外部的访问所修改
interface User {
val nickname: String
}
class FacebookUser(val accountId: Int) : User {
override val nickname = getFacebookName(accountId)
}
class SubscribingUser(val email: String) : User {
override val nickname: String
get() = email.substringBefore('@')
}
FacebookUser.nickname 会把值存在 filed 中，而 SubscribingUser.nickname 用的是一个自定义的 getter，所以每一次都会访问计算
接口中的属性
接口中的属性不是 final 的，它们可以被子类修改
如果任意一个子类中有自定义的 getter，那么不可以使用智能类型转换（即 if (session.user is FacebookUser) 会被编译器报错），因为自定义的 getter 可能每一次返回的是不同的值
可以通过引入一个本地变量来使用智能类型转换
fun analyzeUserSession(session: Session) {
if (session.user is FacebookUser) { // 这里判断的时候得到了一个值
println(session.user.accountId) // 下一次 getter 得到的未必是同一个
}
}
// Compiler error: Smart cast to 'FacebookUser' is impossible, because 'session.user' is a property that has open or custom getter
fun analyzeUserSession(session: Session) {
val user = session.user // 只会在这里有一次 getter
if (user is FacebookUser) {
println(user.accountId)
}
}
// OK
同样的，可变数据类型（mutable variables）也不可以使用智能类型转换
属性拓展
可以拓展已有的属性
val String.lastIndex: Int
get() = this.length - 1
val String.indices: IntRange
get() = 0..lastIndex
拓展属性和拓展函数很类似，没有任何奇妙的优化，所以下面这段代码依然会输出 2 次 “Calculating……”
val String.medianChar
get(): Char? {
println("Calculating...")
return getOrNull(length / 2)
}
fun main(args: Array<String>) {
val s = "abc"
println(s.medianChar)
println(s.medianChar)
}
延迟初始化
Lazy Initialization 或者叫 Late Initialization，以只在第一次被用到的时候才会计算
val lazyValue: String by lazy {
println("Computed")
"Hello"
}
fun main(args: Array<String>) {
println(lazyValue)
println(lazyValue)
}
// 只在声明的时候计算（输出）1 次 "Computed"，main 函数中的访问直接用的 property
fun main(args: Array<String>) {
// no lazyValue usage
}
// 但是因为初始化是 lazy 的，所以只在第一次被用到的时候才会计算，于是不会输出 "Computed"
如果对于一个类的成员，我们在构造函数中没有办法知道它的初始值，那么只能将它初始化成了 null，之后就需要使用 myData?.foo 的形式来访问
但是如果我们能确保在初始化完成后这个成员不可能再是 null，例如我们在 onCreate 函数中（或者别的手段）对其进行了初始化，处理 null 就会显得冗余
就可以使用 lateinit 对其修饰，这样这个类型就不再需要是 nullable 的了
lateinit myData: MyData
// ...
myData.foo
如果因为某些原因，这个成员没有被正确初始化，我们会得到一个运行时错误，但是这个错误不会显示 NullPointerException，而是 UninitializedPropertyAccessException
注意 lateinit 修饰的只能是 var而不可以是 val，其类型不能是基本类型也不能是一个 nullable
可以个 .isInitialized 来判断一个延迟初始化的变量有没有被初始化
面向对象编程
访问级别
- Kotlin 中默认级别是 public 和 final 的，如果需要不是 final 的需要显式说明 open
- Java 中的默认级别是 package-level，同一个包内其他类可见，这个在 Kotlin 中叫做 internal
- override 在 Kotlin 中是强制的，避免意外 override
- protected 在 Java 中仍然对同一个包内的其他类可见，在 Kotlin 中只对子类可见
- private 针对类来说就是私有类，对于 top-level declaration 是对同一个文件中的其他部分可见
- internal 在 JVM 的层面 public + name mangled
- Java 中每一个类需要是单独的类，而 Kotlin 中可以把多个类放在一个文件里
- Kotlin 中的包名称不必遵循
org.company.store的形式，但仍做如此推荐
构造器
Kotlin 中不需要使用 new，直接像访问函数一样就可以构造一个对象
class A
val a = A()
如果构造器足够简单，不需要像 Java 一样显式地写清楚 this.val = val 这样的构造器，Kotlin 会自动赋值
// Kotlin
class Person(val name: String, val age: Int)
// Java
class Person(String name, int age) {
this.name = name;
this.age = age;
}
如果需要更复杂的构造器，可以使用 init
class Person(name: String) {
val name: String // property declaration
init {
this.name = name
// do something else
}
}
注意，只有加上 var 或者 val 才会自动赋值作为域成员，否则就只是普通的构造器的参数
可以修改构造器的访问级别
可以声明二级构造器，例如在矩形的类中声明一个二级的构造器（正方形），当接收一个参数（边长）时，由正方形调用 this(side, side)
class Rectangle(val height: Int, val width: Int) {
constructor(side: Int): this(side, side) {
// ...
}
}
子类的构造器会先调用父类的构造器
open class Parent {
init { print("parent ") }
}
class Child : Parent() {
init { print("child ") }
}
fun main(args: Array<String>) {
Child()
}
// parent child
open class Parent {
open val foo = 1
init {
println(foo)
}
}
class Child: Parent() {
override val foo = 2
}
fun main() {
Child()
}
// 0
这段代码会输出 0
override 一个 property 其实是 override 了它的 getter，而不是 filed
父类（应该）拥有 foo，初始化为 1，并且有一个平凡的 getter，叫做 getFoo()，这个 getter 返回了（父类的） foo
子类（应该）拥有 foo，初始化为 2，并且有一个平凡的 getter，叫做 getFoo()，这个 getter 返回了（子类的） foo，注意这个 getter 会 override 父类的 getter
当新建一个子类的时候，首先调用了父类的构造器，父类的 foo 为 1，并且拥有一个返回了（父类的）foo 的 getter，然后调用 init，在 init 中，会调用 getFoo，由于这是一个子类，那么根据多态，应该调用子类的 getFoo，子类的 getFoo 会返回（子类的）foo 值，而此时子类还没有完成初始化，所以 foo 值为 0
因此，上面这段代码在 Java 中相当于
public class A {
private final String value;
public A(String value) {
this.value = value;
getValue().length(); // call value_B.length() -> call null.length()
}
public String getValue() {
retrun value;
}
}
public class B extends A {
private final String value; // mark it as value_B
public B(String value) {
super(value);
this.value = value; // mark it as value_B
}
@Override
public String getValue() {
retrun value; // mark it as value_B
}
}
类修饰符
enum 是一个类修饰符，而不是一个特殊的关键字
enum class Color {
BLUE, ORANGE, RED
}
Color.BLUE
import mypackage.Color.*
BLUE
enum class Color(val r: Int, val g: Int, val b: Int) {
BLUE(0, 0, 255), ORANGE(255, 165, 0), RED(255, 0, 0);
fun rgb() = (r * 256 + g) * 256 + b
}
BLUE.r
BLUE.rgb()
data 有 equals、copy、hashCode 和 toString 等方法
data class Contact(val name: String, val address: String)
contact.copy(address = "new address")
在 Kotlin 中，== 默认比较它们的 equals，而 === 比较它们是不是同一个引用
在 Java 中，== 比较是否是同一个引用，需要使用 equals 来比较它们
class Foo(val first: Int, val second: Int)
data class Bar(val first: Int, val second: Int)
val f1 = Foo(1, 2)
val f2 = Foo(1, 2)
println(f1 == f2) // false
val b1 = Bar(1, 2)
val b2 = Bar(1, 2)
println(b1 == b2) // true
默认的实现都是比较引用的 equals，但是当类使用 data 修饰时，会自动实现一个比较域成员的 equals，于是就会得到 true
Kotlin 只会使用主构造器中的属性来实现 equals，不会使用类在其他部分定义的变量
当明确知道自己的类考虑了所有考虑的情况时，可以用 sealed 来避免冗余的代码，注意这个是类修饰符，不能用于接口
interface Expr
class Num(val value: Int): Expr
class Sum(val left: Expr, val: Right: Expr): Expr
fun eval(e: Expr): Int = when (e) {
is Num -> e.value
is Sum -> eval(e.left) + eval(e.right)
else -> throw IllegalArgumentException("Unknown expression") // 要加上这句话，否则无法通过编译：when 必须完备
}
sealed class Expr
class Num(val value: Int): Expr
class Sum(val left: Expr, val: Right: Expr): Expr
fun eval(e: Expr): Int = when (e) {
is Num -> e.value
is Sum -> eval(e.left) + eval(e.right)
// OK
}
在 Java 中，如果只写 class A，则作为一个内部类，会默认保存外部类的一个引用，而在 Kotlin 中， class A这种写法默认不会产生这样的引用，即相当于 Java 中的 static class A
如果需要这样一个对外部类的引用，可以使用 inner class A，并通过 @ 标签访问
class A {
class B
inner class C {
this@A
}
}
类委托可以委托一个类来实现一个接口
interface Repository {
fun getById(id: Int): Customer
fun getAll(): List<Customer>
}
interface Logger {
fun logAll()
}
// 原本的写法
class Controller(
repository: Repository,
logger: Logger
): Repository, Logger {
override fun getById(id: Int) = repository.getById(id)
override fun getAll(): List<Customer> = repository.getAll()
override fun logAll() = logger.logAll()
}
// Class Delegation
class Controller(
repository: Repository,
logger: Logger
): Repository by repository, Logger by logger
fun use(controller: Controller) {
controller.logAll()
}
对象
对象在 Kotlin 中，对象是单例的
object KSingleton {
fun foo() {}
}
KSingleton.foo()
对象表达式代替了 Java 中的匿名类（如果只有简单的方法，可以直接使用 Lambda 表达式，如果需要多个方法，那可以使用对象表达式）
对象表达式不是单例的，每一次调用都会新建新的实例，因为有可能会需要使用外部的类传递进来的参数，使用每一次都要实例化
Kotlin 中没有 static 的方法，companion object 可以作为它的替代
Java 中的 static 方法不能重写接口的方法，在 Kotlin 中，companion object 可以重写接口的方法
class C {
companion object {
@JvmStatic fun foo() {}
fun bar() {}
}
}
// Java
C.foo(); // OK
C.bar(); // NO，因为试图将其作为 static 方法来调用
C.Companion.foo(); // OK
C.Companion.bar(); // OK
inner 只能修饰类，不能修饰对象，因为 object 是单例
可以把 object 放在 class 内部作为嵌套
常量
const 用来定义基本类型或者 string，这个常量会在编译时被替换掉
const cal answer = 42
泛型
interface List<E> {
fun get(index: Int): E
}
fun foo(ints: List<Int>) { ... }
fun <T> List<T>.filter(predicate: (T) -> Boolean): List<T>
fun <T> List<T>.firstOrNull(): T?
可以使用 Any 来确保元素不可以为 null
fun <T> foo (list: List<T>) {
for (element in List) {
}
}
foo(listOf(1, null)) // OK
fun <T: Any> foo (list: List<T>) {
for (element in List) {
}
}
foo(listOf(1, null)) // NO
可以使用 where 来进行多个 upper bounds
fun <T: Comparable<T>> max(first: T, second: T): T {
return if (first > second) first else second
}
fun <T> ensureTrailingPeriod(seq: T)
where T: CharSequence, T: Appendable {
if (!seq.endsWith('.') {
seq.append('.')
})
}
使用了泛型的函数，可以用 JvmName 来指定不同的泛型函数名称，这样就可以在 Java 中使用 averageOfDouble，因为字节码有这个函数了
fun List<Int>.average: Double { ... }
@JvmName("averageOfDouble")
fun List<Double>.average(): Double { ... }
编码约定
符号重载
使用 a + b 会自动调用 a.plus(b)
operator fun Point.plus(other: Point): Point {
return Point(x + other.x, y + other.y)
}
Point(1, 2) + Point(2, 3)
重载的运算符左右两边的数据类型可以不一样
operator fun Point.times(scale: Int): Point {
return Point(x * scale, y * scale)
}
Point(1, 2) * 3
单目运算符也可以重载，例如 unaryMinus、not、inc
注意对于 list 这样的类型，+= 的操作会新建一个新的 list，例如下面这段代码会输出 [1, 2, 3, 4] 和 [1, 2, 3]
val list1 = listOf(1, 2, 3)
var list2 = list1
list2 += 4
println(list1)
println(list2)
如果需要，可以把 var 和 listOf 换成 val 和 mutableListOf
在 Kotlin 中，可以使用 < 这些符号比较字符串之间的大小，会自动调用 compareTo() 并和 0 比较，也可以使用 == 比较相等，会调用 equals()
访问键值对也可以使用 map[index] 操作，会调用 map.get(index)
Java 的 String 没有实现 Iterable 接口，但是 Kotlin 中可以通过定义拓展函数的方法重载迭代运算符
operator fun CharSequence.iterator(): CharIterator
for (c in "abc") { ... }
解构式的定义，在本质上也是运算符的重载 argument.component1()
map.forEach { (key, value) -> { ... } }
list 也可以同时遍历下标和元素
for ((inex, element) in list.withIndex()) {
println("$index $element")
}
不需要的参数可以用 _ 跳过
如果一个类（例如 Point）实现了 Comparable 接口，那么在任何其他地方都可以使用 < > 来比较大小，也可以再定义一个 private operator fun Point.compareTo，这样就可以在自己的算法中用新的比较规则，这个规则在代码的其他部分是不可见的
内联函数
run 会运行一个 Lambda 代码段，并把最后一个表达式作为结果
let 可以检测一个参数是不是 nulll
fun getEmail(): Email?
val email = getEmail()
if (meial != null) sendEmailTo(email)
email?.let { e -> sendEmailTo(e) }
getEmail()?.let { sendEmailTo(it) }
如果任意一个子类中有自定义的 getter，那么不可以使用智能类型转换（即 if (session.user is FacebookUser) 会被编译器报错），因为自定义的 getter 可能每一次返回的是不同的值，可以通过引入一个本地变量来使用智能类型转换，而 let 可以简化这个写法
interface Session {
val user: User
}
fun analyzeUserSession(session: Session) {
val user = session.user
if (user is FacebookUser) {
println(user.accountId)
}
}
(session.user as? FacebookUser)?.let {
println(it.accountId)
}
takeIf 返回条件满足时的对象，否则 null
常与 ?.let 连用
issue.takeIf { it.status == FIXED }
person.patronymicName.takeIf(String::isNotEmpty)
takeUnless 与 takeIf 相反
repeat 可以重复一个操作多次，注意这不是一个 built-in 的关键字，而是一个 inline function
repeat(10) {
println("Hello")
}
inline fun repeat(times: Int, action (Int) -> Unit) {
for (index in 0 until times) {
action(index)
}
}
没有内联的 Lambda 表达式会被当做一个类，会带来额外的性能开销，因为内联会把函数题替换掉，而不是调用函数
fun myRun(f: () -> Unit) = f()
fun main(args: Array<String>) {
val name = "Kotlin"
myRun { println("Hi, $name!") }
}
// class Examplekt$main$1
像 filter 这样的函数，都是内联的
但 inline 是 Kotlin 的特性，如果从 Java 调用，那不会有内联
序列
Lambda 是内联的，但是链式调用的中间过程的数据集合都会被产生
val list = listOf(1, 2, -3)
val maxOddSquare = list // [1, 2, -3]
.map { it * it } // [1, 4, 9]
.filter { it % 2 == 1 } // [1, 9]
.max() // 1
序列 .asSequence() 推迟了计算发生的时间，从而避免了中间过程中不断产生集合
val list = listOf(1, 2, -3)
val maxOddSquare = list
.asSequence()
.map { it * it }
.filter { it % 2 == 1 }
.max()
Collections 中，每一次链式调用都会完成计算，因此得到 [m1, m2, m3, m4, f1, f2, f3, f4]
Sequences 中，每次对一个值完成全部的计算，因此得到 [m1, f1, m2, f2, m3, f3, m4, f4]
注意在 Sequences 中，除非需要这个值，否则不会计算
另外，但 Sequences 发现前面的步骤已经不满足时，不会进行后面的步骤
Collections 和 Sequences 的类不是父类子类关系
val seq = generateSequence {
Random.nextInt(5).takeIf { it > 0 }
}
println(seq.toList())
Sequences 都是懒惰计算的，除非到了需要的时候，否则不会完成计算
例如下面这个例子，问的只是 .first()，而第一个元素已知，所以不会去计算后面的元素，因此输出 “Generating” 0 次
val numbers = generateSequence(3) { n ->
println("Generating element...")
(n + 1).takeIf { it < 7 }
}
println(numbers.first()) // 3
yield 在 Kotlin 中不是语言特性、不是关键字，只是一个函数
但它是懒惰的，只在需要时被调用
val numbers = sequence {
var x = 0
while (true) {
yield(x++)
}
}
numbers.take(5).toList() // [0, 1, 2, 3, 4]
fun mySequence() = buildSequence {
println("yield one element")
yield(1)
println("yield a range")
yieldAll(3..5)
println("yield a list")
yieldAll(listOf(7, 9))
}
println(mySequence()
.map { it * it }
.filter { it > 10 }
.take(1))
// 不会输出任何一条 yield ...
// 因为 take() 不是最终操作
println(mySequence()
.map { it * it }
.filter { it > 10 }
.first())
// 只会输出 "yield one element" 和 "yield a range"
// first() 是终端操作
// 首先计算 1，经过 map 得到 1，被过滤
// 然后计算 3，经过 map 得到 9，被过滤
// 再计算 4，经过 map 得到 16，找到答案，程序结束，不会继续后面的计算
带接收器的 Lambda
拓展函数和 Lambda 结合，可以看作带接收器的 Lambda，又叫拓展的 Lambda
val sb = StringBuilder()
sb.appendln("Alphabet: ")
for (c in 'a'..'z') {
sb.append(c)
}
sb.toString()
这样的代码需要重复多次变量名，可以使用 with 简化
val sb = StringBuilder()
with (sb) {
appendln("Alphabet: ")
for (c in 'a'..'z') {
append(c)
}
toString()
}
事实上，with 是一个函数，sb 作为第一个参数，而这个 Lambda 表达式是第二个参数，即
with (sb, { this.toString() } )
val isEven: (Int) -> Boolean = { it % 2 == 0 }
val isOdd: Int.() -> Boolean = { this % 2 == 1 }
isEven(0)
1.isOdd()
使用库函数简化一些计算
people.filter { it.age < 21 }.size
people,count { it.age < 21 }
people.sortedBy { it.age }.reversed()
people.sortedByDesending { it.age }
people
.map { person ->
person.takeIf { it.isPublicProfile }?.name
}
.filterNotNull()
people.mapNotNull { person ->
person.takeIf { it.isPublicProfile }?.name
}
if (person.age !in map) {
map[person.age] = mutableListOf()
}
map.getValue(person.age) += person
val group = map.getOrPut(person.age) { mutableListOf() }
group += person
val map = mutableMapOf<Int, MutableList<Person>>()
for (person in people) {
if (person.age !in map) {
map[person.age] = mutableListOf()
}
map.getValue(person.age) += person
}
people.groupBy { it.age }
groupBy()
// Write the name of the function that performs groupBy for Sequences in a lazy way.
groupingBy()
eachCount() // counts elements in each group
Kotlin 和 Java 中的数据类型
使用 Int 时，Kotlin 将其转换为 int 字节码，当使用 Int? 时，Kotlin将其转换为 Integer 字节码
List<Int> 仍然会被当成 List<Integer>
Array<Int> 是 Integer[]，IntArray 是 int[]
Kotlin 中的 String 就是 Java 中的 String，但隐藏了一些容易混淆的方法，例如 replaceAll 接收正则表达式
Any 是 Object，也是 Int 这些基本类型（在 Kotlin 中）的基类
除非是内联的 Lambda 表达式，否则会被变成 Function0、Function1 这样，内联的表达式会直接替换
可以显式地在 Kotlin 中调用 invoke()
println(arrayOf(1, 2) == arrayOf(1, 2))
Kotin 中的数组和 Java 中的数组是一样的，没有魔法，所以上面的比较结果是 false，可以使用 contentEquals 来比较它们的内容
当只使用 Kotlin（而不需要从字节码层面被 Java 使用）时，那么没有理由使用 Array，应该始终使用 List
Nothing 是 Kotlin 中的底层类型，Nothing 可以看做是任何类型的子类，但在字节码层面，仍然会被转化为 void，因为 Java 中没有可以表示 Nothing 的类型
Unit 表示函数返回时没有有意义的返回值，用来替代 Java 的 void，其在字节码层面就是 void，完全等价
Nothing 表示函数永远不会返回，例如在 fail() 函数中抛出异常，这是一个永远不会执行完成的函数
Kotlin 中，TODO() 是一个内联的函数，可以接受一个参数 String 表示一些备注信息，它的类型也是 Nothing
直接使用 return 也可以获得 Nothing 类型
fun greetPerson(person: Person) {
val name = person.name ?: return
println("Hello, $name!")
}
val answer = if (timeHasPassed()) {
42
} else {
fail("Not ready")
}
fun fail(message: String) {
throw IllegalStateException(message)
}
这里 answer 会被认为是 Any，因为当条件成立时，42 是一个 Int，而 fail() 是 Unit，这两个类型的公共父类是 Any，这与期望不合
val answer = if (timeHasPassed()) {
42
} else {
fail("Not ready")
}
fun fail(message: String): Nothing {
throw IllegalStateException(message)
}
这里 answer 会被认为是 Int，因为当条件成立时，42 是一个 Int，而 fail() 是 Nothing，Nothing 可以看做是任何类型的子类
最简单的、也是唯一的一个 Nothing? 类型是 null 常量
类型后面加 ! 例如 String! 往往只会出现在错误信息中，例如数据类型不匹配的错误，来表示这个类型是来自 Java 的
// Java
public class Session {
public String getDescription() {
return null;
}
}
// Kotlin
val session = Session()
val description = session.description // description 的类型是 "String!"
println(description.length) // NullPointerException
这样会使得 Kotlin 中的 Nullable 检查毫无用处，因为依然可能出现 Null Pointer Exception，而不需要明确地检查是不是为 null
这种情况可以在 Java 代码中增加注解 @Nullable、@NonNull 等，这样 Kotlin 就可以强制检查 Nullable 的数据
// Java
public class Session {
@Nullable
String getDescription() {
return null;
}
}
// Kotlin
val session = Session()
val description = session.description
println(description.length) // 无法通过编译
可以将 @NotNull 设置为默认（由 JSR-305 支持的 @ParametersAreNonnullByDefault、@MyNonnullByDefault），这样只需要注释 @Nullable 的类型即可
也可以根据自己的需要指定另一个默认值
但注意 Kotlin 将默认 NotNull 的数据类型、却接收了 null 这样的问题，只是看作警告，需要添加 -Xjsr305=strict 编译选项，Kotlin 才会把它们看作错误
预防 Null Pointer Exception，除了使用 Java 注解，还可以在 Kotlin 代码中明确数据类型，例如 String? 或者 String，而不要让编译器自己猜测
明确数据类型可以得到以下不同的结果：
// Java
public class Session {
String getDescription() {
return null;
}
}
// Kotlin
val session = Session()
val description: String? = session.description // 这是 String? 类型
println(description?.length) // 输出 null
// Java
public class Session {
String getDescription() {
return null;
}
}
// Kotlin
val session = Session()
val description: String = session.description // 这是 String 类型，不能为空
println(description.length) // 抛出 IllegalStateException，不是 NUllPointerException
kotlin.List 和 java.util.List 是一样的，MutableList 继承自 List
注意只读和不可变是不一样的，不能对 List 使用 add，因为它没有 mutating 方法，但可以通过 MutableList 来修改
val mutableList = mutableListOf(1, 2, 3) //#1
val list: List<Int> = mutableList //#2
mutableList.add(4) //#3
println(list) //#4
这依然会输出 [1, 2, 3, 4]
在底层，kotlin.List 有一个子类 kotlin.MutableList，而 kotlin.MutableList 会用 java.util.ArrayList 来实现
使用只读类型，例如 List，可以防止自己意外地调用 .add() 这样的方法，除非把它明确地交给 Mutable，那就可以修改