HugMua的博客

数据类型数字 Number、布尔 Boolean、字符 Char 数组 Array 字符串模版 String 返回值 Unit、Nothing、Any 1条件控制控制 for、while 区间 Range 条件 if else、when

以下函数，一个参数的重载默认了异常信息，两个参数的重载可以自定义异常信息。条件必须满足，代码才会继续往下执行。

因为成功传入的是值T失败传入的是异常Throwable。返回的结果是成功就组合执行runCatching(transform)，transform将T值转换成R值，执行成功就返回R值，执行异常就返回异常。返回的结果是失败就执行传入的transform处理异常并返回一个值，执行成功就返回值，执行失败就返回异常。返回的结果是成功就得到值，失败就执行传入的onFailure来处理异常并返回一个值。返回的结果是成功就得到值，失败就得到null，不关心异常。返回的结果是失败就得到异常，成功就得到null，不关心值。

用于表示时间度量，简化了时间单位的换算、计算时间差、操作间隔、比较等场景。

提供Lambda嵌套Lambda的代码结构。为任意对象增加函数或属性。实现类似于英语句子的结构。让对象像函数一样直接调用。

虽然Kotlin中的集合支持链式调用，但是序列才类似于Java中的Stream，只是没有parallel模式。一样是操作分为三步：创建序列、中间操作、终止操作。

class MyException() : Exception() //自定义异常。

【代码】kotlin - 线程 Thread。

首先调用File对象的walk方法得到FileTreeWalk实例，接着依次为该实例设置具体的条件，包括遍历深度、是否匹配文件夹、文件扩展名，以及最后的文件队列循环处理。流操作 读 readBytes() public fun File.readBytes(): ByteArray以 ByteArray 形式返回读取到的全部文件内容，上限2G。File.readText(charset: Charset = Charsets.UTF_8): String以 St

在 Standard.kt 标准库中提供了一些便捷的内置高阶函数，可以帮助我们写出更简洁高效的代码。这些函数都是在一个对象上执行一个代码块，形成一个临时作用域可以访问该对象而无需其名称，不同的是哪个对象在代码块中使用以及整个表达式的返回值是什么。......................................................

有时候需要将原生数据类型或String类型的参数通过构造封装在一个类中，然后提供一些方法对参数进行操作，使其使用起来成为一个强类型来提高代码健壮性。而一般我们写代码只是传递原生数据类型或String，JVM 会针对原生数据类型或String进行优化，但不会针对包装类做任何处理，使用包装类会创建对象意味着性能的损耗（内存占用，运行效率，GC回收）。.........

也就是被 var 属性委托的对象的类要重写 getValue()、setValue()方法，被 val 属性委托的对象的类要重写 getValue() 方法。类似于 Java 类中私有化成员变量并提供公共访问的写法（封装），Kotlin 一般不这样写，毕竟对 getter/setter 使用可见性修饰符就能对属性的操作加以限制，幕后属性是用来实现懒加载的。如果一个类有两个概念上相同的属性，一个是公共 API 的一部分，另一个是实现细节，那么使用下划线作为私有属性名称的前缀。

Kotlin却极度弱化了静态方法这个概念，提供了比静态方法更好用的语法特性，同样是通过【类名.函数名】来调用。适合写“全是静态方法的工具类”。假设定义顶层函数 method() 的文件名为 Helper.kt，编译器会创建一个 HelperKt.java，在Java中就可以 HelperKt.method() 调用了。

Kotlin v1.5：直接子类必须跟父类在同一个 Gradle Module 且同一包名下。Kotlin v1.1：直接子类必须跟密封类在同一文件中，间接子类可以再不同文件中。Kotlin v1.0：直接子类必须是密封类的内部类。继承起来，接口比类更灵活，又有助于实现多类型层级嵌套。enum 更在意类型。

声明枚举类使用 enum 关键字。每个枚举常量都是一个对象，用逗号分隔。格式：enum class 类名｛ 常量名，常量名，常量名...｝默认属性 oridinal 该枚举常量的顺序，从0开始 name 该枚举常量的名字 默认函数 values( ) 获取所有枚举常量 valueof( ) 获取对应枚举常量 enum class Demo { RED, BLUE, YELLOW, GREEN}println...

我们经常会创建一些保存数据的类，Kotlin 使用 data 关键字声明一个数据类，解决 JavaBean 极其臃肿的写法。

对SAM（单抽接口）一般使用 Lambda 更便捷，当需要重写多个抽象方法时，只能选择匿名对象了。访问外部函数中的局部变量不用加 final（

一些调用前未初始化的错误示范： 幕后字段 Backing Field关联知识点 ：幕后属性 Backing Property访问器 getter & setter类外的属性延迟初始化 lateinit 关联知识点 ：懒加载 by lazy()①属性初始化必须在属性使用之前，否则报错②不支持外部注入工具将它直接注入到Java字段中

有可见性修饰或注解的时候，constructor 不能省略。写法和Java类似。次构造不能委托给主构造，因为没有主构造。主构造使用默认参数简化次构造重载。次构造使用委托调用主构造。

abstract class Demo() { abstract var id:Long abstract fun method() abstract fun show():Int}声明抽象使用 abstract 关键字。抽象类默认是open的无需声明，其中的抽象属性和抽象函数只有声明而没有实现，子类必须全部重写带有 abstract 修饰的抽象成员。abstract class Demo() { abstract var id:Long abst..

Kotlin 中所有类的父类是 Any（Java中是Object），它默认提供三个函数：equals()、hashCode()、toString()。 非抽象类默认不可被继承（相当于Java中被声明为final的类）。使用 open 关键字修饰后的类可以被继承，再将类中允许被覆盖的函数和属性也用 open 修饰（否则不允许出现重名，函数重载不受影响(函数同名但参数列表不同) ）。在子类中使用 override 关键修饰被覆盖的函数或属性。 和声明变量一样，继承的写法也是使用冒号，即子类的类型是父类，没.

类Kotlin中所有类的父类是 Any（Java中是Object），它默认提供三个函数：equals()、hashCode()、toString()。 Kotlin中类以及成员属性和成员函数默认都是 final 修饰的，无法被继承和重写。继承 final（默认） 不允许类被继承，不允许成员属性和成员函数被重写。 详见： open 允许类被继承，允许成员属性和成员函数被重写。 abstract 声明抽象类、抽象属性、抽象函数。 详见.

同样支持SAM转换。底层是将Java的SAM翻译成函数类型。

编译时常量会被编译器以内联的方式进行编译（直接用值替换掉调用处的变量名进行编译），使程序结构简单，方便编译器和JVM做优化。

递归：在函数体中调用函数自身。先执行完所有递归调用（保存了每次调用的状态），用最终拿到的值再往回一步步计算结果。 尾递归：调用自身的语句处于函数体中最后一行，仅调用函数自身不包含其它操作。 递归的问题：使用少量代码完成需要多次重复的计算，算法逻辑容易理解但效率不高，每递归一次就要开辟一个方法栈（函数空间）保存状态，次数过多消耗性能还可能导致内存溢出。而循环迭代就没有这种问题，使用变量每次接收上次计算的结果，避免反复开辟函数空间。 尾递归优化：属于编译期优化，通过 tailrec 关键字修饰，函数符合.

【运算符重载】该函数使用 operator 修饰符 该函数的名称必须被声明为特定的名称，以将对应的操作符映射为这个函数的调用 参数必须符合该操作符的规定，例如 + 的重载就不能多于一个参数，也不能为空参数 函数名 运算符 一元运算符 inc dec ++ -- 二元运算符 plus minus times div rem a + b a - b a * b a

使用 infix 关键字修饰的函数，就是一个中缀表达式，使用起来就是一个运算符，更接近自然语言便于阅读。

扩展函数不修改源文件的情况下，可以动态的为一个类扩展新功能，也无需继承重写。 一个类的扩展函数可以在同包目录下直接调用，出了这个范围需要导包使用。(不必像 Java 为了定义一个方法而专门创建工具类，可以把公共函数写到一个 .kt 文件中，通过 import 导入就可以使用了)。格式fun 类名.方法名(参数列表) : 返回值类型 { 方法体 }fun ClassName.methodName(params1:Int, params:Int) : Int { }举例：为Str

【函数声明】可见性修饰符 关键字 函数名称 (参数列表) : 返回值类型 {函数体}public fun getNum(x:Int, y:Int): Int{ return x + y}【返回值类型】关键字 说明 Unit 不显示声明返回值类型都会返回Unit类型，类似Java中void用法 Nothing 真正的没有返回值，函数不return会执行失败（抛异常） Any //没有返回值类型返回的是Unit，可不写fun

用处：消除类型强转的烦恼，保证类型安全。泛型约束形变 & 协变Kotlin Java in T 逆变 ? super T 下限通配符 out T 协变 ? extends T 上限通配符 ...

通常情况下一个变量只能携带一个值，解决方法是自定义数据类，写法过于复杂。Kotlin元组可以把多个值同时赋值给一个变量，或给多个变量同时赋值。Pair 二元元组：可以携带两个值Tuple 三元元组：可以携带三个值val two: Pair<String，Int> = Pair(18,"张三")val three = Triple(22,"李四",true)println("""三元元组的内容：${three.first}、$...

Map 类型Key具有唯一性，存入 Entry 时当 Key 重复时会覆盖之前的 Value。to 关键字本身是一个中缀表达式，返回一个 Pair。创建方式 举例 mapOf () val map1 = mapOf( 'A' to 3, 2 to "哈哈", false to true ) //随意类型 val map2 = mapOf<Int,String>( 1 to "你", 2 to "我", 3 to "他") /...

元素不可变的集合类型：List<E>、Set<E>、Map<K,V>元素可变的集合类型：MutableList<E>、MutableSet<E>、MutableMap<K,V>List 类型创建方式 举例 listOf () mutableListOf () Set 类型创建方式 举例 setOf () mutableSetOf () Map 类型.

创建方式 Array arrayOfXXX () arrayOf () val array1:Array<String> = arrayOf("你", "我", "他") val array2:Array<Person> = arrayOf(person1, person2) intArrayOf () shortArrayOf () longArrayOf () floatArrayOf

增减步长) 的控制规则，改用 range 代替。( a , b ) 开区间，不含首尾。[ a , b ] 闭区间，包含首尾。效果同上，于v1.9版本加入，改善 until 的可读性，使得看起来意思更直观。1,2,3,4,5,6,7,8,9（不含尾元素）对应方法 a.reversed(b)对应方法 a.contains(b)打乱元素的顺序，返回一个素组。随机返回一个元素的值。返回区间中元素的个数。false，5在区间里。true，5在区间里。true，3在区间里。返回所有元素的平均值。

【if else】作为表达式使用会返回一个值，因此不需要再用Java中的三元运算符了val a = 1val b = 2 //通常用法if (a < b) max = aelse{ max = b print("max赋值了b")} //作为表达式，取代三元运算符max = if (a < b) a else b //赋值给变量，需要有else，赋值的语句要放在最后一行max = if (a < b){ a}else{

任何提供了迭代器的对象都可以被循环遍历。

在声明变量的时候，就要指定它是Nullable可空类型 还是Non-Null非空类型。默认为非空类型，即该变量不会为null，为null报错。声明 Non-Null 非空类型：val a :String = "你好"val b :String = null //赋值为null报错：Null can not be a value of a non-null type String声明 Nullable 可空类型：val c :String? = nullval d = c...

【字符串模版】符号 说明 "文本内容" 转义字符串（和Java一样） """文本内容""" 原生字符串（里面内容原原本本打印，包括换行和转义字符） $ 引用变量 ${} 调用方法和运算 //增var str = "2" + 32 //用 + 操作符连接字符串，第一个元素要是字符串str += "00" //字符串拼接println(str) //打印：23200 //改val aa = "小明和朋友玩得很开心！"val bb = "

【一元运算符】运算符 名称 举例 结果 ++ 自增 a = 2 b = ++a //a先自增，再把值赋给b a = 3 b = 3 a = 2 b = a ++ //把a赋值给b，a再自增 a = 3 b = 2 - - 自减 a = 2 b = - - a a = 1 ...