Kotlin入门

2019-05-12 本文已影响0人小牧扎特

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 表达式（）