写给 Java 开发者的 Kotlin 入坑指南

介绍

本文主要讲解 Kotlin 基础语法。

主要内容

快速认识 Kotlin

基础语法

扩展函数

委托

结尾

正文

快速认识 Kotlin

Kotlin 是著名 IDE 公司 JetBrains 创造出的一门基于 JVM 的语言。Kotlin 有着一下几个特色：

• 简洁，1行顶5行
• 安全，主要指“空安全”
• 兼容，与 Java 兼容
• 工具友好，IntelliJ 对 Kotlin 简直不要太友好

JetBrains 不只创造了 Kotlin，还创造了著名的 IntelliJ IDEA。Android 开发者使用的 Android Studio 就是基于 IntelliJ 改造出来的。

基础语法

1. 全部 Kotlin 类都是对象 (Everything in Kotlin is an object)

与 Java 不同是：Kotlin 没有基本数据类型 (Primitive Types)，全部 Kotlin 里面的类都是对象，他们都继承自: Any这个类；与 Java 相似的是，Kotlin 提供了以下的内置类型：

Type	Bit width	备注
Double	64	Kotlin 没有 double
Float	32	Kotlin 没有 float
Long	64	Kotlin 没有 long
Int	32	Kotlin 没有 int/Integer
Short	16	Kotlin 没有 short
Byte	8	Kotlin 没有 byte

思考题1：

既然 Kotlin 与 Java 是兼容的，那么 Kotlin Int 与 Java int、Java Integer 之间是什么关系？

思考题2：

Kotlin Any 类型与 Java Object 类型之间有什么关系？

2. 可见性修饰符 (Visibility Modifiers)

修饰符	描述
public	与Java一致
private	与Java一致
protected	与Java一致
internal	同 Module 内可见

3. 变量定义 (Defining Variables)

定义一个 Int 类型的变量:

var a: Int = 1
复制代码

定义一个 Int 类型的常量(~~不可变的变量、~~只读的变量)

val b: Int = 1
复制代码

类型可推导时，类型申明可省略:

val c = 1
复制代码

语句末尾的;无关紧要:

val d: Int;
d = 1;
复制代码

小结：

• var 定义变量
• val 定义常量(~~不可变的变量、~~只读变量)
• Kotlin 支持类型自动推导

思考题3：

Kotlin val 变量与 Java 的 final 有什么关系？

4 空安全 (Null Safety)

定义一个可为空的 String 变量:

var b: String? = "Kotlin"
b = null
print(b)
// 输出 null
复制代码

定义一个不可为空的 String 变量:

var a: String = "Kotlin"
a = null
// 编译器报错，null 不能被赋给不为空的变量
复制代码

变量赋值：

var a: String? = "Kotlin"
var b: String = "Kotlin"
b = a // 编译报错，String? 类型不能够赋值给 String 类型

a = b // 编译经过
复制代码

空安全调用

var a: String? = "Kotlin"
print(a.length) // 编译器报错，由于 a 是可为空的类型
print(a?.length) // 使用?. 的方式调用，输出 null
复制代码

Elvis 操做符

// 下面两个语句等价
val l: Int = if (b != null) b.length else -1
val l = b?.length ?: -1

// Elvis 操做符在嵌套属性访问时颇有用
val name = userInstance?.user?.baseInfo?.profile?.name?: "Kotlin"
复制代码

小结：

• T 表明不可为空类型，编译器会检查，保证不会被 null 赋值
• T? 表明可能为空类型
• 不能将 T? 赋值给 T
• 使用 instance?.fun() 进行空安全调用
• 使用 Elvis 操做符为可空变量替代值，简化逻辑

5. 类型检查与转换 (Type Checks and Casts)

类型判断、智能类型转换：

if (x is String) {
    print(x.length) // x 被编译自动转换为 String
}
// x is String 相似 Java 里的 instanceOf
复制代码

不安全的类型转换 as

val y = null
val x: String = y as String
//抛异常，null 不能被转换成 String
复制代码

安全的类型转换 as?

val y = null
val z: String? = y as? String
print(z)
// 输出 null
复制代码

小结：

• 使用 is 关键字进行类型判断
• 使用 as 进行类型转换，可能会抛异常
• 使用 as? 进行安全的类型转换

6. if 判断

基础用法跟 Java 一毛同样。它们主要区别在于：Java If is Statement，Kotlin If is Expression。所以它对比 Java 多了些“高级”用法，懒得讲了。

7. for 循环

跟 Java 也差很少，随便看代码吧：

// 集合遍历，跟 Java 差很少
for (item in collection) {
	print(item)
}

// 辣鸡 Kotlin 语法
for (item in collection) print(item)

// 循环 1，2，3
for (i in 1..3) {
    println(i)
}

// 6，4，2，0
for (i in 6 downTo 0 step 2) {
    println(i)
}

复制代码

8. when

when 就至关于高级版的 switch，它的高级之处在于支持模式匹配(Pattern Matching):

val x = 9
when (x) {
    in 1..10 -> print("x is in the range")
    in validNumbers -> print("x is valid")
    !in 10..20 -> print("x is outside the range")
    is String -> print("x is String")
    x.isOdd() -> print("x is odd")
    else -> print("none of the above")
}
// 输出：x is in the range
复制代码

9. 相等性 (Equality)

Kotlin 有两种类型的相等性：

• 结构相等 (Structural Equality)
• 引用相等 (Referential Equality)

结构相等：

// 下面两句两个语句等价
a == b
a?.equals(b) ?: (b === null)
// 若是 a 不等于 null，则经过 equals 判断 a、b 的结构是否相等
// 若是 a 等于 null，则判断 b 是否是也等于 null
复制代码

引用相等：

print(a === b)
// 判断 a、b 是否是同一个对象
复制代码

思考题4：

val a: Int = 10000
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA)
print(boxedA === anotherBoxedA)
// 输出什么内容?
复制代码

思考题5：

val a: Int = 1
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA)
print(boxedA === anotherBoxedA)
// 输出什么内容?
复制代码

10. 函数 (Functions)

fun triple(x: Int): Int {
    return 3 * x
}
// 函数名：triple
// 传入参数：不为空的 Int 类型变量
// 返回值：不为空的 Int 类型变量
复制代码

11. 类 (Classes)

类定义

使用主构造器(Primary Constructor)定义类一个 Person 类，须要一个 String 类型的变量：

class Person constructor(firstName: String) { ... }
复制代码

若是主构造函数没有注解或者可见性修饰符，constructor 关键字可省略:

class Person(firstName: String) { ... }
复制代码

也可使用次构造函数(Secondary Constructor)定义类：

class Person {
    constructor(name: String) { ... }
}

// 建立 person 对象
val instance = Person("Kotlin")
复制代码

init 代码块

Kotlin 为咱们提供了 init 代码块，用于放置初始化代码：

class Person {
    var name = "Kotlin"
    init {
        name = "I am Kotlin."
        println(name)
    }

    constructor(s: String) {
        println(“Constructor”)
    }
}

fun main(args: Array<String>) {
    Person("Kotlin")
}
复制代码

以上代码输出结果为：

I am Kotlin.
Constructor
复制代码

结论：init 代码块执行时机在类构造以后，但又在“次构造器”执行以前。

12. 继承 (Inheritance)

• 使用 open 关键字修饰的类，能够被继承
• 使用 open 关键字修饰的方法，能够被重写
• 没有 open 关键字修饰的类，不可被继承
• 没有 open 关键字修饰的方法，不可被重写
• 以 Java 的思想来理解，Kotlin 的类和方法，默认状况下是 final 的

定义一个可被继承的 Base 类，其中的 add() 方法能够被重写，test() 方法不可被重写：

open class Base {
    open fun add() { ... }
    fun test() { ... }
}
复制代码

定义 Foo 继承 Base 类，重写 add() 方法

class Foo() : Base() {
    override fun add() { ... }
}
复制代码

• 使用 : 符号来表示继承
• 使用 override 重写方法

13. This 表达式 (Expression)

class A {

    fun testA(){	}

    inner class B { // 在 class A 定义内部类 B

        fun testB(){	}

        fun foo() {
            this.testB() // ok
            this.testA() // 编译错误
            this@A.testA() // ok
            this@B.testB() // ok
        }
    }
}
复制代码

小结：

• inner 关键字定义内部类
• 在内部类当中访问外部类，须要显示使用 this@OutterClass.fun() 的语法

14. 数据类 (Data Class)

假设咱们有个这样一个 Java Bean:

public class Developer {
        private String name;

        public Developer(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Developer developer = (Developer) o;
            return name != null ? name.equals(developer.name) : developer.name == null;
        }

        @Override
        public int hashCode() {
            int result = name != null ? name.hashCode() : 0;
            return result;
        }

        @Override
        public String toString() {
            return "Developer{" + "name='" + name + '}';
        }
    }
复制代码

若是咱们将其翻译成 Kotlin 代码，大约会是这样的:

class Developer(var name: String?) {

    override fun equals(o: Any?): Boolean {
        if (this === o) return true
        if (o == null || javaClass != o.javaClass) return false
        val developer = o as Developer?
        return if (name != null) name == developer!!.name else developer!!.name == null
    }

    override fun hashCode(): Int {
        return if (name != null) name!!.hashCode() else 0
    }

    override fun toString(): String {
        return "Developer{" + "name='" + name + '}'.toString()
    }
}
复制代码

然而，Kotlin 为咱们提供了另一种选择，它叫作数据类:

data class Developer(var name: String)
复制代码

上面这一行简单的代码，彻底能替代前面咱们的写的那一大堆模板 Java 代码，甚至额外多出了一些功能。若是将上面的数据类翻译成等价的 Java 代码，大概会长这个样子：

public final class Developer {
   @NotNull
   private String name;

   public Developer(@NotNull String name) {
      super();
      this.name = name;
   }

   @NotNull
   public final String getName() {   return this.name;   }

   public final void setName(@NotNull String var1) {    this.name = var1;   }

   @NotNull
   public final Developer copy(@NotNull String name) {   return new Developer(name);   }

   public String toString() {   return "Developer(name=" + this.name + ")";   }

   public int hashCode() {   return this.name != null ? this.name.hashCode() : 0;   }

   public boolean equals(Object var1) {
      if (this != var1) {
         if (var1 instanceof Developer) {
            Developer var2 = (Developer)var1;
            if (Intrinsics.areEqual(this.name, var2.name)) {
               return true;
            }
         }
         return false;
      } else {
         return true;
      }
   }
}
复制代码

能够看到，Kotlin 的数据类不只为咱们提供了 getter、setter、equals、hashCode、toString，还额外的帮咱们实现了 copy 方法！这也体现了 Kotlin 的简洁特性。

序列化的坑

若是是旧工程迁移到 Kotlin，那么可能须要注意这个坑:

// 定义一个数据类，其中成员变量 name 是不可为空的 String 类型，默认值是 MOMO
data class Person(val age: Int, val name: String = "Kotlin")
val person = gson.fromJson("""{"age":42}""", Person::class.java)
print(person.name) // 输出 null
复制代码

对于上面的状况，因为 Gson 最初是为 Java 语言设计的序列化框架，并不支持 Kotlin 不可为空、默认值这些特性，从而致使本来不可为空的属性变成null，本来应该有默认值的变量没有默认值。

对于这种情，市面上已经有了解决方案:

• kotlinx.serialization
• moshi

15. 扩展 (Extensions)

如何才能在不修改源码的状况下给一个类新增一个方法？好比我想给 Context 类增长一个 toast 类，怎么作？

若是使用 Java，上面的需求是没法被知足的。然而 Kotlin 为咱们提供了扩展语法，让咱们能够轻松实现以上的需求。

扩展函数

为 Context 类定义一个 toast 方法：

fun Context.toast(msg: String, length: Int = Toast.LENGTH_SHORT){
    Toast.makeText(this, msg, length).show()
}
复制代码

扩展函数的使用：

val activity: Context? = getActivity()
activity?.toast("Hello world!")
activity?.toast("Hello world!", Toast.LENGTH_LONG)
复制代码

属性扩展

除了扩展函数，Kotlin 还支持扩展属性，用法基本一致。

思考题6：

上面的例子中，咱们给不可为空的 Context 类增长了扩展函数，所以咱们在使用这个方法的收须要判空。实际上，Kotlin 还支持咱们为 可为空的 类增长扩展函数：

// 为 Context? 添加扩展函数
fun Context?.toast(msg: String, length: Int = Toast.LENGTH_SHORT){
    if (this == null) {    //do something }
    Toast.makeText(this, msg, length).show()
}
复制代码

扩展函数使用：

val activity: Context? = getActivity()
activity.toast("Hello world!")
activity.toast("Hello world!", Toast.LENGTH_LONG)
复制代码

请问这两种定义扩展函数的方式，哪一种更好？分别适用于什么情景？为何？

16. 委托 (Delegation)

Kotlin 中，使用by关键字表示委托：

interface Animal {
    fun bark()
}

// 定义 Cat 类，实现 Animal 接口
class Cat : Animal {
    override fun bark() {
        println("喵喵")
    }
}

// 将 Zoo 委托给它的参数 animal
class Zoo(animal: Animal) : Animal by animal

fun main(args: Array<String>) {
    val cat = Cat()
    Zoo(cat).bark()
}
// 输出结果：喵喵
复制代码

属性委托 (Property Delegation)

其实，从上面类委托的例子中，咱们就能知道，Kotlin 之因此提供委托这个语法，主要是为了方便咱们使用者，让咱们能够很方便的实现代理这样的模式。这一点在 Kotlin 的委托属性这一特性上体现得更是淋漓尽致。

Kotlin 为咱们提供的标准委托很是有用。

by lazy 实现”懒加载“

// 经过 by 关键字，将 lazyValue 属性委托给 lazy {} 里面的实现
val lazyValue: String by lazy {
    val result = compute()
    println("computed!")
    result
}

// 模拟计算返回的变量
fun compute():String{
    return "Hello"
}

fun main(args: Array<String>) {
    println(lazyValue)
    println("=======")
    println(lazyValue)
}
复制代码

以上代码输出的结果：

computed!
Hello
=======
Hello
复制代码

因而可知，by lazy 这种委托的方式，可让咱们轻松实现懒加载。 其内部实现，大体是这样的：

lazy 求值的线程模式: LazyThreadSafetyMode

Kotlin 为lazy 委托提供三种线程模式，他们分别是：

• LazyThreadSafetyMode.SYNCHRONIZED
• LazyThreadSafetyMode.NONE
• LazyThreadSafetyMode.PUBLICATION

上面这三种模式，前面两种很好理解：

1. LazyThreadSafetyMode.SYNCHRONIZED 经过加锁实现多线程同步，这也是默认的模式。
2. LazyThreadSafetyMode.NONE 则没有任何线程安全代码，线程不安全。

咱们详细看看LazyThreadSafetyMode.PUBLICATION，官方文档的解释是这样的：

Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value, but only the first returned value will be used as the value of [Lazy] instance.

意思就是，用LazyThreadSafetyMode.PUBLICATION模式的 lazy 委托变量，它的初始化方法是可能会被多个线程执行屡次的，但最后这个变量的取值是仅以第一次算出的值为准的。即，哪一个线程最早算出这个值，就以这个值为准。

by Delegates.observable 实现"观察者模式"的变量

观察者模式，又被称为订阅模式。最多见的场景就是：好比读者们订阅了MOMO公众号，每次MOMO更新的时候，读者们就会收到推送。而观察者模式应用到变量层面，就延伸成了：若是这个的值改变了，就通知我。

class User {
    // 为 name 这个变量添加观察者，每次 name 改变的时候，都会执行括号内的代码
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("name 改变了：$old -> $new")
    }
}

fun main(args: Array<String>) {
    val user = User()
    user.name = "first: Tom"
    user.name = "second: Jack"
}
复制代码

以上代码的输出为：

name 改变了：<no name> -> first: Tom
name 改变了：first: Tom -> second: Jack
复制代码

思考题7：

lazy 委托的LazyThreadSafetyMode.PUBLICATION适用于什么样的场景？

结尾

看完了？别走！留下思考题答案吧！

继续阅读请点击-->【Kotlin Jetpack 实战】传送门