Kotlin 是 JetBrain 开发的基于JVM 的语言， IntelliJ 作为它的主要开放 IDE。
1. 接入 Kotlin
在 Project 的 Gradle 中加入 Kotlin 的相关引用
buildscript {
ext.kotlin_version = '1.3.30'
repositories {
google()
jcenter()
maven { url "https://jitpack.io" }
}
dependencies {
...
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
}
}
然后在 app 模块的 Gradle 添加 Kotlin 插件和引用
apply plugin: 'com.android.application'
apply plugin: 'kotlin-android' // 可在代码中直接通过布局组件 id 调用组件
apply plugin: 'kotlin-android-extensions'
...
dependencies {
implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
...
}
如果你的依赖含有注解器，且由 Kotlin 实现，这是还需要添加 kapt 插件。例如使用非常广泛的第三方图片加载库 —— Glide
...
apply plugin: 'kotlin-kapt' // 添加 kapt 插件
...
dependencies {
// annotationProcessor 'com.github.bumptech.glide:compiler:4.8.0' Java 的方式，如果直接 Kotlin 引用会报找不到实现类错误
kapt 'com.github.bumptech.glide:compiler:4.8.0'
}
2. 基本类型
2.1 数字
| TYPE | Bit Width |
|---|---|
| Double | 64 |
| Float | 32 |
| Long | 64 |
| Int | 32 |
| Short | 16 |
| Byte | 8 |
值得注意的是，Kotlin 对于数字没有隐式拓宽转换。即
val a: Int = 1
val b: Long = a // 编译器会报错
val c: Long = a.toLong() // 正确的赋值方式
2.2 字符
字符用 Char 类型表示，在 Kotlin 中，它们不能直接当作数字用。
2.3 布尔
布尔用 Boolean 表示，它只有两个值： true 与 false
2.4 数组
数组在 Kotlin 中使用 Array 类来表示，使用规则：
val nums = arrayOf(1, 2, 3) // 创建整形数组 [1, 2, 3]
val asc = Array(5, { i -> (i * 5).toString() }) // 创建字符串数组 ["0", "1", "4", "9", "25"]
另外 Kotlin 也有无装箱开销的专门的类来表示原生类数组，如 ByteArray、ShortArray、IntArray等等。这些类与 Array 并没有继承关系，但是它们有相同的方法属性集。
2.5 字符串
字符串用 String 类型表示。字符串是不可变的，它的元素字符可以使用索引运算符访问：s[i] 。可以用 for 循环迭代字符串：
for (c in str) {
println(c)
}
原始字符串 使用三个引号 """ 分界符括起来，内部没有转义并且可以包含换行以及任何其他字符：
val text = """
for (c in "foo")
print(c)
"""
字符串模板 即在字符串中插入一小段代码，并把结果合并到字符串中，以 $ 开头：
val i = 10
println("i = $i") // 输出"i = 10"
// 或者用花括号括起来任意表达式
val s = "abc"
println("$s.length is ${s.length}") // 输出"abc.length is 3"
2.6 集合
| Java 类型 | Kotlin 只读类型 | Kotlin 可变类型 |
|---|---|---|
Iterable<T> |
Iterable<T> |
MutableIterable<T> |
Collection<T> |
Collection<T> |
MutableCollection<T> |
Set<T> |
Set<T> |
MutableSet<T> |
List<T> |
List<T> |
MutableList<T> |
ListIterator<T> |
ListIterator<T> |
MutableListIterator<T> |
Map<K, V> |
Map<K, V> |
MutableMap<K, V> |
Map.Entry<K, V> |
Map.Entry<K, V> |
MutableMap.Entry<K, V> |
Kotlin 标准库中为集合提供了大量的方法，例如：
val list = listOf(2, 1, -1, 3, -2)
list.filter { it > 0 }.let(::println) // 过滤
list.takeWhile { it > 0 }.let(::println) // 遍历至第一个不符合条件的数据为止
list.sorted().let(::println) // 排序
3 控制流
if 表达式
// 传统用法
var max: Int
if (a > b) {
max = a
} else {
max = b
}
// 作为表达式
val max = if (a > b) a else b
when 表达式
when (x) {
1 -> print("x==1")
2 -> print("x==2")
else -> {
print("x is neither 1 nor 2")
}
}
for 循环
// 区间递增或递减
for (i in 1..3) println(i)
for (i in 6 downTo 0 step 2) println(i)
// 集合
for (item in list) println(item)
list.forEach { println(it) }
// 数组
for (i in array.indices) println(array[i])
4. 类与对象
4.1 类
Kotlin 中使用关键字 class 声明类
class Person(val name: String, val age: Int) { // 主构造函数
constructor(name: String) : this(name, 0) // 次构造函数
init { // 初始化模块
println("My name is $name, I'm $age years old.")
}
}
主构造函数不能包含任何代码，初始化的代码可以放到以 init 关键字作为前缀的 初始化块（initializer blocks） 中。
4.2 数据类
data class User(val name: String, val age: Int)
会为 User 类提供以下的方法：
- 所有属性的 getters （对于
var定义的还有 setters） equals()hashCode()toString()copy()
4.3 继承
Kotlin 中一个可被继承的类必须声明为 open
open class Base(val name: String)
class Dervied(name: String) : Base(name)
4.4 对象
伴生对象
Kotlin 通过伴生对象的方式来实现类似 Java 类中静态方法，即用 companion 关键字标记内部对象
class MyClass {
companion object Factory {
fun create(): MyClass = MyClass()
}
}
// 该伴生对象的成员可通过只使用类名作为限定符来调用
val instance = MyClass.create()
单例
上面的例子有点像 Java 中单例模式的写法，在 Kotlin 中有更为直接的写法：
object ProviderManager {
fun registerDataProvider(provider: Provider) {
// ...
}
}
这称为 对象声明 。并且它总在 object 关键字后跟一个名称。就像变量声明一样，对象声明不是一个表达式，不能用于赋值语句。
4.5 扩展
函数扩展
fun MutableList<Int>.swap(index1: Int, index2: Int) {
val tmp = this[index1] // "this"对应该列表
this[index1] = this[index2]
this[index2] = tmp
}
属性扩展
val <T> List<T>.lastIndex: Int
get() = size - 1
其它
This 表达式
// Java 写法
MainActivity.this
// Kotlin 写法
this@MainActivity
空安全
Kotlin 允许为空变量，但声明时必须在类型后面加 ?
var a: String? = "abc"
a = null // ok
var b: String = "abc"
b = null // 编译报错
允许空值的变量的调用
// 传统方法
if (a != null) {
println("Length of string is ${a.length}")
}
// 安全调用，不会 crash
println("Length of string is ${a?.length}"
Elvis 操作符
val l = a?.length ?: -1
作用域函数
Kotlin 标准库包含几个作用域函数，用于在对象的上下文执行代码块。它们有一些共同点，也有一些区别。
let 常用于使用非空值执行代码块，返回值为lambda表达式
val str: String? = "Hello"
val length = str?.let {
println("${it.length}")
it.length
}
also 适用于将上下文对象作为参数执行一些不更改对象的操作，例如log 输出等
// 上面的代码等价于
val str: String? = "Hello"
val length = str?.length?.also { println(it) }
apply 常用于对象配置，可解读为“将以下赋值应用与对象”，返回对象本身
val bundle = Bundle().apply {
putString("name", "Tom")
putInt("age", 4)
}
with 可以理解为“使用此对象，执行以下操作”，返回值为 lambda 表达式
val numbers = mutableListO("one", "two", "three")
val firstAndLast = with(numbers) {
"The first element is ${first()}, the last element is ${last()}"
}
println(firstAndLast)
run 可理解为 with 和 let 的结合体，返回值为为 lambda 表达式
val service = MutiportService("http://example.kotlinlang.org", 80)
val result = service.run {
port = 8080
query(prepareRequest() + "to port $port")
}
// 用 let 写的同样效果
val result = service.run {
it.port = 8080
it.query(prepareRequest() + "to port $port")
}
区别
- 使用场景不一样
- 上下文对象是
this还是it（let和also为it，其它为this） - 返回值是对象自身还是 lambda 表达式（）
