Kotlin学习笔记（不包含协程）

前言

有句话说的好：种一棵树的最好时间第一是十年前，其次是现在。我第一次听说kotlin，大概是18年12月的时候。真正开始系统学习是在20年上半年，现在stdlib版本都更到1.4.31了貌似，我看好kotlin，写篇笔记方便查阅。

---

kotlin推进时间表

零碎知识点

• 定义一个普通变量

//定义一个普通变量
public final var MAX_MONTH:Int=12

• kotlin实现java的静态方法

kotlin没有static关键字，但是有伴生对象，可以实现Java中静态方法调用和静态变量修改，静态方法使用@JvmStatic关键字实现

companion object{
        /**点击选择接口回调*/
        interface ResultHandler{
            abstract fun handle(time: String)
        }
        var MAX_MONTH:Int=12
    }

lateinit关键字

延迟加载：Kotlin会使用null来对每一个用lateinit修饰的属性做初始化，
而基础类型是没有null类型，所以这个关键字只适用非基础类型

for循环

private var star: Int = 0
private var end: Int = 100
//正遍历
for (index in star..end){}
//倒序遍历
for (index in end downto start){}
//可以设置遍历步长(step使用)
for (index in star..end step 2){}
//不包含末尾 (util使用)
for (index in star util end){}
//遍历一个数组/列表，想同时取出下标和元素(withIndex使用)
val array = arrayOf("a", "b", "c")
for ((index,e) in array.withIndex()){
    println("下标=$index----元素=$e")
}
//遍历一个数组/列表，只取出下标(indices使用)
val array = arrayOf("a", "b", "c")
for (index in array.indices){
    println("index=$index")//输出0，1，2
}
//遍历取元素(element)
val array = arrayOf("a", "b", "c")
for (element in array){
    println("element=$element")//输出a,b,c
}

嵌套类与内部类

如果类嵌套，默认是嵌套类。内部类需要使用innner修饰。前者相当于Java的静态内部类，而后者持有外部类的引用。

空安全设计

在 Kotlin 里面，所有的变量默认都是不允许为空的。
这种类型之后加 ? 的写法，在 Kotlin 里叫可空类型
你可以在类型右边加一个 ? 号，解除它的非空限制，比如

var name: String? = null

「可能为空」的变量，Kotlin 不允许用。就算你加上if语句判断也会报错。
意思是即使你检查了非空也不能保证下面调用的时候就是非空，因为在多线程情况下，其他线程可能把它再改成空的。

kotlin的[safe call]非空确认之后再调用方法

var view: View? = null
view?.setBackgroundColor(Color.RED)

加双感叹号就是「non-null asserted call」，意思是肯定不为空，出问题我负责，这样就和java没什么区别了，但也就享受不到 Kotlin 的空安全设计带来的好处了。（在编译时做检查，而不是运行时抛异常）

---

延迟初始化

告诉编译器我没法第一时间就初始化，但我肯定会在使用它之前完成初始化的。延迟初始化对变量的赋值次数没有限制。

---

类型推断

有些类型（比如String）直接赋值就完事了，有类型推断。

---

声明变量除了使用var还可以使用val

val 是 Kotlin 在 Java 的「变量」类型之外，又增加的一种变量类型：只读变量。它只能赋值一次，不能修改。

---

可见性

在 Kotlin 里变量默认就是 public 的，而对于其他可见性修饰符，之后再说。

---

函数

Java 的方法（method）在 Kotlin里叫函数（function），其实没啥区别，或者说其中的区别我们可以忽略。对任何编程语言来讲，变量就是用来存储数据，而函数就是用来处理数据。

对比java没有返回值，返回void的情况，Kotlin 里是返回 Unit，并且可以省略。

fun main(): Unit {}

---

基本类型

在 Kotlin 中，所有东西都是对象。

var number: Int = 1 // 还有 Double Float Long Short Byte 都类似
var c: Char = 'c'
var b: Boolean = true
var array: IntArray = intArrayOf(1, 2) // 类似的还有 FloatArray DoubleArray CharArray 等，intArrayOf 是 Kotlin 的 built-in 函数
var str: String = "string"

原先在 Java 里的基本类型，类比到 Kotlin 里面，条件满足如下之一就不装箱：

不可空类型。

使用 IntArray、FloatArray 等。

java中的implement和extends在kotlin中都可以用“：”实现。

---

• open关键字的使用。

Kotlin 里的类默认是 final 的，而 Java 里只有加了 final 关键字的类才是 final 的。
所以，当你定义了一个类，没有加open的话，他是不能被继承，而open关键字就是用来解除这个限制的。

---

强转（is和as关键字使用）

在 Java 里，需要先使用 instanceof 关键字判断类型，再通过强转来调用。
Kotlin 里同样有类似解决方案，使用 is关键字进行「类型判断」，并且因为编译器能够进行类型推断，可以帮助我们省略强转的写法：

fun main() {
    var activity: Activity = NewActivity()
    if (activity is NewActivity) {
        //强转由于类型推断被省略了
        activity.action()
    }
}

fun main() {
    var activity: Activity = NewActivity()
    // '(activity as? NewActivity)' 之后是一个可空类型的对象，所以，需要使用 '?.' 来调用
    (activity as? NewActivity)?.action()
}

如果强转成功就执行之后的调用，如果强转不成功就不执行。

---

构造器 constructor

熟悉java构造方法的我们知道，通常是public，那在kotlin中构造方法是如何实现的呢？

class User {
    val id: Int
    val name: String

    constructor(id: Int, name: String) {
 // 没有 public
        this.id = id
        this.name = name
    }
}

---

init的使用，初始化代码块

在java中，我们知道想要在构造方法前做些事情，只要两个大括号就行（static关键字可加可不加）
在kotlin中

class User {
    init {
        // 初始化代码块，先于下面的构造器执行
        //如果是主构造器，因为主构造器没有代码体，所以init紧随其后执行。
    }
    constructor() {
    }
}

---

object关键字

java中的是大写开头的Object，在 Kotlin 中变成了 Any，和 Object 作用一样：作为所有类的基类。

而object关键字意思很直接：创建一个类，并且创建一个这个类的对象。

单例实现使用kotlin变得简单，用object修饰实现的单例，是一个饿汉式的单例，实现了线程安全。
与java相比，不需要维护实例变量xxinstance,也不需要getInstance方法。

• 匿名类如何写？使用object关键字

val listener = object: ViewPager.SimpleOnPageChangeListener() {
    override fun onPageSelected(position: Int) {
        // override
    }
}   

和 Java 创建匿名类的方式很相似，只不过把 new 换成了 object:：

Java 中 new 用来创建一个匿名类的对象；
Kotlin 中 object: 也可以用来创建匿名类的对象；
这里的 new 和 object: 修饰的都是接口或者抽象类。

• Java 静态变量和方法的等价写法：companion object 变量和函数

可以省略对象名，比如下面代码，其实B写不写都无所谓，都是用A.c直接拿到变量

class A {
    companion object B {
        var c: Int = 0
    }
}

---

顶层声明

top-level property / function 声明

除了静态函数这种简便的调用方式，Kotlin 还有更方便的东西：「top-level declaration 顶层声明」。其实就是把属性和函数的声明不写在 class 里面，这个在 Kotlin 里是允许的。

调用也简单，直接通过 import包名.函数名,就能用了。还能用包名区分相同名字的方法，真是方便。

---

常量 关键字const

Java中不说了，public static final。
Kotlin 的常量必须声明在对象（包括伴生对象）或者「top-level 顶层」中。
Kotlin 新增了修饰常量的 const 关键字。

class Sample {
    companion object {
        const val CONST_NUMBER = 1
    }
}
​
const val CONST_SECOND_NUMBER = 2

Kotlin 中只有基本类型和 String 类型可以声明成常量。java中一些static final的类也可以作为常量，但在kotlin中却不行。因为可以通过set方法，修改，可以理解成「伪常量」
原因是 Kotlin 中的常量指的是 「compile-time constant 编译时常量」。

---

数组

Kotlin 中的数组是一个拥有泛型的类，创建函数也是泛型函数，和集合数据类型一样。

kotlin中数组不支持协变。
子类数组对象不能赋值给父类的数组变量。java中却可以。

//在java中可以
String[] strs = {"a", "b", "c"};
Object[] objs = strs; // success

val strs: Array = arrayOf("a", "b", "c")
val anys: Array = strs //会报错compile-error: Type mismatch

---

集合

Kotlin 和 Java 一样有三种集合类型：List、Set 和 Map。
Kotlin 中创建一个 List 特别的简单，有点像创建数组的代码。而且 Kotlin 中的 List 多了一个特性：支持 covariant（协变）。也就是说，可以把子类的 List 赋值给父类的 List 变量：

val strs: List = listOf("a", "b", "c")
val anys: List = strs // success

在java中，会报错：不兼容

List strList = new ArrayList<>();
List