《Kotlin核心编程》2021版复习记录

目录

• • [0 前言](#0 前言)
  • [1 基础语法](#1 基础语法)
  • • [1.1 数据类型](#1.1 数据类型)
    • [1.2 数组](#1.2 数组)
    • [1.3 集合](#1.3 集合)
    • [1.4 遍历数据和集合](#1.4 遍历数据和集合)
    • [1.5 函数声明返回值类型](#1.5 函数声明返回值类型)
    • [1.6 var 和 val](#1.6 var 和 val)
  • [2 高阶函数和lambda表达式](#2 高阶函数和lambda表达式)
  • • [2.1 高阶函数](#2.1 高阶函数)
    • [2.2 方法和成员引用](#2.2 方法和成员引用)
    • [2.3 链式调用](#2.3 链式调用)
    • [2.4 扩展函数](#2.4 扩展函数)
    • [2.5 面向表达式编程](#2.5 面向表达式编程)
    • • [2.5.1 when表达式](#2.5.1 when表达式)
      • [2.5.2 for循环](#2.5.2 for循环)
      • [2.5.3 in](#2.5.3 in)
    • [2.6 字符串相等](#2.6 字符串相等)
  • [3 面向对象](#3 面向对象)
  • • [3.1 类](#3.1 类)
    • • [3.1.1 接口注意事项](#3.1.1 接口注意事项)
    • [3.2 初始化](#3.2 初始化)
    • [3.3 构造方法](#3.3 构造方法)
    • [3.4 类访问控制](#3.4 类访问控制)
    • [3.5 使用final真的好吗](#3.5 使用final真的好吗)
    • [3.6 类访问修饰符](#3.6 类访问修饰符)
    • • [3.6.1 访问修饰符和java比较](#3.6.1 访问修饰符和java比较)
    • [3.7 多继承相关](#3.7 多继承相关)
    • • [3.7.1 get 和 set](#3.7.1 get 和 set)
      • [3.7.2 内部类解决多继承问题](#3.7.2 内部类解决多继承问题)
      • [3.7.2 委托代替多继承](#3.7.2 委托代替多继承)
    • [3.8 data class 数据类](#3.8 data class 数据类)
    • [3.9 Pair和Triple](#3.9 Pair和Triple)
    • [3.10 伴生对象](#3.10 伴生对象)
    • [3.11 天生的单例 object](#3.11 天生的单例 object)
  • [4 代数数据类型和模式匹配](#4 代数数据类型和模式匹配)
  • • [4.1 代数类型](#4.1 代数类型)
    • [4.2 模式匹配](#4.2 模式匹配)
  • [5 类型系统](#5 类型系统)
  • • [5.1 null](#5.1 null)
    • [5.2 ？：操作符](#5.2 ？：操作符)
    • [5.3 Any？](#5.3 Any？)
    • [5.4 kotlin中装箱和拆箱](#5.4 kotlin中装箱和拆箱)
    • [5.5 泛型](#5.5 泛型)
    • [5.6 泛型擦除](#5.6 泛型擦除)
    • [5.7 协变](#5.7 协变)
  • [6 lambda和集合](#6 lambda和集合)
  • • [6.1 调用java的函数式接口](#6.1 调用java的函数式接口)
    • [6.2 with和apply](#6.2 with和apply)
    • [6.3 map](#6.3 map)
    • [6.4 filter和count](#6.4 filter和count)
    • [6.5 别样的求和方式：sumBy、sum、fold、reduce](#6.5 别样的求和方式：sumBy、sum、fold、reduce)
    • [6.6 分组groupBy](#6.6 分组groupBy)
    • [6.7 扁平化，处理嵌套集合flatten、flatMap](#6.7 扁平化，处理嵌套集合flatten、flatMap)
    • [6.8 集合继承关系](#6.8 集合继承关系)
    • [6.9 可变集合和只读集合](#6.9 可变集合和只读集合)
    • [6.10 惰性集合](#6.10 惰性集合)
    • • [6.10.1 序列](#6.10.1 序列)
      • [6.10.2 序列和链式调用区别](#6.10.2 序列和链式调用区别)
      • [6.10.3 序列是无限的](#6.10.3 序列是无限的)
    • [6.11 内联函数](#6.11 内联函数)
    • • [6.11.1 避免使用内联函数的情形](#6.11.1 避免使用内联函数的情形)
    • [6.12 非局部返回](#6.12 非局部返回)
    • [6.13 具体化参数类型](#6.13 具体化参数类型)
  • [7 多态和扩展](#7 多态和扩展)
  • • [7.1 子类型多态](#7.1 子类型多态)
    • [7.2 参数多态](#7.2 参数多态)
    • [7.3 对类进行扩展](#7.3 对类进行扩展)
    • [7.4 run、let、also、takeIf](#7.4 run、let、also、takeIf)
    • [7.5 扩展注意事项](#7.5 扩展注意事项)
  • [8 元编程（反射）](#8 元编程（反射）)
  • • [8.1 程序和数据](#8.1 程序和数据)
    • [8.2 常见的元编程方法](#8.2 常见的元编程方法)
    • [8.3 反射](#8.3 反射)
    • [8.4 注解](#8.4 注解)
    • [8.5 注解处理器](#8.5 注解处理器)
  • [9 设计模式](#9 设计模式)
  • • [9.1 创建型模式](#9.1 创建型模式)
    • • [9.1.1 工厂模式](#9.1.1 工厂模式)

0 前言

准备先回顾一下kotlin。

每天看到哪里就会写到哪里，随缘记录一下我觉得比较常用的思想和知识点。暂时粗略过一遍，方面查看。后续有时间再仔细看看；

争取不和学flutter一样暂时烂尾hh。

1 基础语法

1.1 数据类型

和java一样Byte、Short、Int、Long、Float、Double、Char、Boolean 但是没有包装类型。

val a: String = "Hello, World!"

1.2 数组

IntArray 是Kotlin中表示原生整型数组（int[]）的一个类型别名

val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5)
val doubleArray: DoubleArray = doubleArrayOf(1.1, 2.2, 3.3)
val stringArray: Array<String> = arrayOf("Kotlin", "Java", "Python")

1.3 集合

val list = mutableListOf("Kotlin", "Java", "Python")
val set = mutableSetOf("Kotlin", "Java", "Python")
val map: MutableMap<Int, String> = mutableMapOf(1 to "Kotlin", 2 to "Java", 3 to "Python")

1.4 遍历数据和集合

// 部分遍历
intArray.forEachIndexed{ index, value ->
    println("$index : $value")
  }
for ((i,j) in intArray.withIndex()){
    println("$i : $j")
}
map.forEach {
    println("${it.key} : ${it.value}")
}

1.5 函数声明返回值类型

声明返回值为Int类型，有时候可以不用声明，但是我一般为了避免错误，还是都会显示声明。

fun sum(x: Int,y: Int): Int  = x + y

1.6 var 和 val

var 变量

val 引用不可变，对照java中用了final关键字。

开发中优先使用val,val不行再用var

2 高阶函数和lambda表达式

2.1 高阶函数

高阶函数就是函数的入参或返回值也是函数的函数。

 (Int) -> Unit

通过 -> 来组织参数类型和返回值类型，左边是参数，右边是返回值。

多个参数

 (Int,String) -> Unit

还可以给参数指定名字

  (x: Int,y: String?) -> Unit

如果这个函数变量作为参数也是可不选（为空）

 ( (x: Int,y: String?) -> Unit)?

2.2 方法和成员引用

val p1 = ::Person
p1("tian", 18).test()

2.3 链式调用

fun add(x: Int,y: Int,z: Int) = {
	x+y+z
}
fun add(x: Int) = { y: Int ->
  {z: Int -> x+y+z}
}

一般函数有多个参数，然后最后一个参数为函数的时候可以柯里化。 就是用直接{

}。

2.4 扩展函数

fun View.invisible(){
	this.visibility = View.INVISIBLE
}

2.5 面向表达式编程

表达式：可以返回值的语句。

2.5.1 when表达式

2.5.2 for循环

for(i in 1..5 step 2) {
    println(i)
}
for(i in 5 downTo 1) {
    if(i == 3) break
    println(i)
}

for(i in 1 until 5) {
    if(i == 3) continue
    println(i)
}
val list4 = listOf(1,2,3)
list4.forEach {
    println("it: $it")
}

list4.forEachIndexed { index, element ->
    println("$index: $element")
}
for ((index,value) in list4.withIndex()){
	println("$index: $value")
}

2.5.3 in

val flag = 1 in listOf(1,3,4)
println(flag)

2.6 字符串相等

==用来比较值

===用来比较引用

3 面向对象

3.1 类

和java区别

3.1.1 接口注意事项

3.2 初始化

init语句块

延迟初始化 lateinit和by lazy

by lazy 需要和val 连用，也就是引用不可变

lateinit 则是用于var，而且不能用于基本类型，如Int、Long等

3.3 构造方法

从构造方法需要直接或者间接委托给主构造方法。

3.4 类访问控制

类和方法默认不可继承或重写，需要加上open关键字 （final修饰）

继承和接口实现都是用：

3.5 使用final真的好吗

3.6 类访问修饰符

internel

内部类使用private修饰

3.6.1 访问修饰符和java比较

3.7 多继承相关

骡马问题

继承骡马的后代继承谁的run方法？

有歧义

3.7.1 get 和 set

3.7.2 内部类解决多继承问题

需要inner

3.7.2 委托代替多继承

委托 ，调用A的A方法，其实是B类的A方法来执行

3.8 data class 数据类

3.9 Pair和Triple

3.10 伴生对象

companian object

类似static，但不是真的static

如果真static需要有@jvm...的一个注解

3.11 天生的单例 object

object 表达式

4 代数数据类型和模式匹配

4.1 代数类型

4.2 模式匹配

5 类型系统

5.1 null

5.2 ？：操作符

5.3 Any？

5.4 kotlin中装箱和拆箱

5.5 泛型

5.6 泛型擦除

5.7 协变

6 lambda和集合

6.1 调用java的函数式接口

6.2 with和apply

6.3 map

6.4 filter和count

6.5 别样的求和方式：sumBy、sum、fold、reduce

6.6 分组groupBy

6.7 扁平化，处理嵌套集合flatten、flatMap

以后再看

6.8 集合继承关系

6.9 可变集合和只读集合

和java互操作时候注意：

6.10 惰性集合

6.10.1 序列

6.10.2 序列和链式调用区别

6.10.3 序列是无限的

6.11 内联函数

主要是优化lambda表达式带来的开销

简单来说就是编译过程中把函数放到该调用的位置，避免额外生成类和调用的开销。

6.11.1 避免使用内联函数的情形

不内联

noinline

6.12 非局部返回

6.13 具体化参数类型

7 多态和扩展

7.1 子类型多态

7.2 参数多态

7.3 对类进行扩展

不会修改类本身，避免类被污染。

扩展函数不会带来额外的性能消耗。

7.4 run、let、also、takeIf

run

let

also

takeIf

7.5 扩展注意事项

8 元编程（反射）

8.1 程序和数据

元编程就像⾼阶函数⼀样，是⼀种更⾼阶的抽象，⾼阶函数将函数作为输⼊或输出，⽽元编程则是将程序本⾝作为输⼊或输出。

8.2 常见的元编程方法

kotlin中主要还是反射

8.3 反射

8.4 注解

8.5 注解处理器

9 设计模式

9.1 创建型模式

9.1.1 工厂模式

用单例代替工厂类

伴⽣对象创建静态工厂方法