Kotlin
特点：简洁、安全、实用
简洁性：
??①努力地保证你写的代码都具有实际的意义，而不是仅仅为了满足代码结构的需要。许多标准的Java样板代码，例如getter、setter以及将构造方法的参数赋值给字段的逻辑，在kotlin中都是隐式的。
??②kotlin有丰富的标准库，让你用库方法调用来代替这些冗长重复的代码段
安全性：
??可以防止程序出现某些类型的错误。如Kotlin不需要指定所有的类型声明，因为许多情况下编译器会自动推断出类型。还有具体的：①提供方法来处理可空数据，避免NullPointerException；②避免ClassCastException，Kotlin可以做类型检查
实用性
?? 帮助解决实际项目的问题；Kotlin 易于学习；开发环境好用
1. kotln基础
1.1 类型
1.1.1 基础类型被统一为对象类型
在Java中数据类型被分为基本数据类型和引用数据类型。在kotlin中所有的数据类型都是引用数据类型。与Java中的数据类型对应，kotlin中的数据类型有如下几种:
fun main(args: Array<String>) {
12.toString()
}
1.1.2 分为可空类型和非空类型
Java的NullPointException是经常遇到的异常，也是最让人头疼的一个异常。Kotlin为了解决这个问题，引进了可空类型，将运行时可能发生异常提前到编译期发现。
Kotlin中有可空类型，这种类型表示取值可能为空；而一般类型，则取值不能为空。区别是类型后面有一个？，表示这个类型是可空的。
举个栗子：
1.1.3 基类类型为Any和Any?
Any类型是kotlin中所有非空类型的根类型，Any？可以是任何可空类型的根类型，也兼容非空类型
与java对比
- Any和Object看起来很像，但Any不能等同java.lang.Object
- Any中定义的方法有：toString()、equals()、hashCode()
- Object类中定义的方法有：toString()、equals()、hashCode()、getClass()、clone()、finalize()、notify()、notifyAll()、wait()、wait(long)、wait(long,int)11个
在Java中，成员变量是有默认值的；但是在kotlin中，成员变量没有默认值。如果不给默认值，就会报错
1.1.4 不需要返回值时类型为Unit
Kotlin中返回值为空时，类型为Unit，相当于Java中的void，代表无返回值，Unit可以省略。 只不过Unit在Kotlin中是一个类，而void在Java中是一个修饰符
当一个函数没有返回值的时候，我们用Unit来表示这个特征，而不是null，大多数时候我们不需要显示地返回Unit，或者声明一个函数的返回值是Unit，编译器会推断它。
如果将一个函数声明为参数类型，那么返回值类型不能省略
1.1.5 永远不会返回的类型为Nothing
Kotlin中Nothing表示函数不会正常结束，一般而言就是会抛异常
1.2变量
1.2.1 变量声明统一为var和val
在Kotlin中变量的声明以关键字开始，然后是变量名称，最后可以加上类型（不加也可以，不加的话需要给变量赋值）。
声明变量的关键字：
① val（来自value）—— 不可变引用。使用val声明的变量不能在初始化之后再次赋值，对应于Java的final 变量。
② var（来自 variable）—— 可变引用。这种变量的值可以改变，对应的是普通（非final）的Java变量。
默认情况下，应尽可能使用 val 关键字来声明所有的 Kotlin 变量，仅在必要的时候换成var。
1.2.2 常量声明和定义可写在顶层文件或者伴生对象
const：在kotlin中的顶级属性，会以getter（val 和 var）/setter（var才有）的形式暴露给Java，如果你想让其以public static final的字段呈现给调用者，可以在var 或者val前面加上const修饰符。
1.2.3 常规属性声明, 构造函数内属性声明
1.2.4 属性访问器, getter 和 setter
1.3 函数
1.3.1 常规函数的声明和定义
Kotlin 相对于Java来说, 主要有以下不同
声明函数使用 fun 关键字;
参数可以指定默认值;
返回值在参数列表后面, 如果是 Unit, 可以省略
1.3.2 重写父类函数
Java 重写父类函数如下图所示, 其中Override仅仅是一个注解, 可以省略的
package com.package1;
public class Test1 {
private String name;
private final int age;
private final String sex;
private String phone = "10086";
public Test1(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = (sex != null) ? sex : "mate";
}
public String setName () {
return setName("default");
}
public String setName (String name) {
this.name = name;
return this.name;
}
}
class TestChild1 extends Test1{
public TestChild1(String name, int age, String sex) {
super(name, age, sex);
}
public String setName() {
return super.setName();
}
@Override
public String setName(String name) {
return super.setName(name);
}
}
Kotlin 里面，使用fun修饰函数时,默认的为final修饰,不能被重写,只有手动添加open,子类使用override重写， override 作为了一个修饰符, 用于标明该方法是重写的父类函数, 并且是强制的, 不然会提示错误
实施此举措, 是为了避免误写父类函数而造成不必要的麻烦
package com.package1
open class Test(private var name: String,
private val age: Int,
private val sex: String = "mate") {
private var phone = "10086"
open fun setName(name: String = "default"): String {
this.name = name
return this.name
}
}
class TestChild(
private var name: String,
private val age: Int,
private val sex: String = "mate"
) : Test (name, age, sex) {
override fun setName(name: String): String {
return super.setName(name)
}
}
1.3.3 类的构造函数
默认构造函数：如果没有自定义任何构造函数，那么就会有一个默认无参的构造函数可以调用，这点跟Java一样；
主构造函数：定义在类名后面的构造函数就是主构造函数，个数<=1；
次构造函数：定义在类体内的构造函数都是次构造函数，个数 >=0；
//案例1，没有主构造函数，只有一个默认的无参构造函数
class Test1 {}
//案例2，有一个主构造函数，默认的无参构造函数无法使用
class Test2 (name: String) {
var name: String = name
}
//案例3，有一个主构造函数和一个次构造函数
class Test3(name: String) {
var nameT: String = name
var ageT: Int? = null
constructor(name: String, age: Int) : this(name) {
ageT = age
}
}
//案例4，只有一个次构造函数
class Test4 {
var nameT: String? = null
var ageT: Int? = null
constructor(name: String, age: Int) {
nameT = name
ageT = age
}
}
//案例5，有一个无参主构造函数和两个次构造函数
class Test5() {
var nameT: String? = null
var ageT: Int? = null
var sexT: String? = null
constructor(name: String, age: Int):this() {
nameT = name
ageT = age
}
constructor(sex: String):this() {
sexT = sex
}
}
1.4 类
1.4.1 文件类
Kotlin 这个文件可以只声明定义方法, 变量, 常量等, 它不归属于任何类, 写法与写脚本类似, 使用上与Java静态类类似
1.4.2 内部类
Kotlin 与 Java 的实现方式类似, 只不过多了一个inner关键字, 标明这是一个内部类, 是持有父类引用的
1.4.3 嵌套类
Kotlin 与 Java 的实现方式依然类似, 但还是有些区别
Java 里面嵌套类, 需要加上 static 修饰符
Kotlin 里面不需要加特殊的修饰符, 默认就是嵌套类, 如果想成为内部类持有父类引用, 需要主动加上 inner 关键字
1.4.4 数据类 data
Kotlin 为Java bean做了更深的优化, 提供了data关键字, 修饰用于描述数据的类，与java的写法对比 data数据类并且会自动添加拷贝函数, 解构函数
还会自动重写 hashCode, equals, toString 函数, 建议属性为 val. var也是可以的, 但做hashmap key可能会出问题
1.4.5 密封类 sealed
Kotlin 提供了一种 sealed 关键字, 用于限制类继承解构
使用sealed修饰的类就是 open 类, 抽象类
所有子类必须写在sealed类的内部
由于编译器知道一共有几种类型，可用来优化 when 对分支的判断：
后期新增类型，却忘记修改 when 分支，最后走了 else 默认情况。（译器会提醒未穷举不给通过）。
很明确只存在几种情况，却为了满足编译器的要求写无效分支。（不必再写 else 默认分支）。
1.4.6 接口 interface
在接口中声明的属性要么是抽象的，要么提供访问器的实现。
1.4.7 单例对象 object
Java 实现单例方式有很多种, 实现较为繁琐
Kotlin 就极为简单, class 修饰符替换为 object 即可
1.5 逻辑
1.5.1 for
Kotlin 里面 for 的形式相对于Java来说有较多扩展, 使用起来更加方便, 只要遍历的对象能提供 Iterator 即可
只要对象实现 Iterable 或者 Iterator 接口就可以按照Kotlin的方式使用for
fun main() {
val list = listOf(1, "aaa", '|')
for (i in list) {
println("$i")
}
println("---------------------")
for ((index, value) in list.withIndex()) {
println("$index-->$value")
}
println("---------------------")
// []
for (i in 0..3) {
println("$i")
}
println("---------------------")
// [)
for (i in 0 until 3) {
println("$i")
}
println("---------------------")
//[]
for (i in 3 downTo 1) {
println("$i")
}
println("---------------------")
// 步长2
for (i in 0..4 step 2) {
println("$i")
}
}
1.5.2 while
Java 和 Kotlin 里面的 while/do…while 使用上没有什么区别
1.5.3 when
Java 里面使用switch进行分支判断, 要求类型是同一种
Kotlin 里面去除了 switch, 使用 when 进行替代
分支可以是同类型, 也可以是判断表达式
可以判断集合元素是否相同(set)
也可以判断集合元素内容和序列是否相同(list)
同时 when 还是一种表达式
1.5.4 if-else
Java 和 Kotlin 里面的 if - else 使用上没有什么区别
但除此之外, Kotlin 里面 if - else 也是一个表达式
Kotlin 没有三目运算符 A ? B : C, 一般是使用 if - else 进行代替
1.5.5 try-catch
Java 和 Kotlin 里面的 try - catch 使用上没有什么区别
但除此之外, Kotlin 里面 try - catch 也是一个表达式, 是可以将值赋值给变量的
1.6 访问修饰符
访问修饰符的含义
Java 和 Kotlin 访问修饰符是类似的, 但个别的 Kotlin 有改进, 有些默认修饰符也不太相同
Kotlin 里面有三种访问修饰符, public, private, internal, 分别代表公开, 私有, 和模块内, 与Java对比少了包可见
默认情况下如果没有写任何修饰符, 就默认为 public final, 公开但不可以被重写
如果需要继承类或者重写函数, 在声明时需要主动加上open
如果需要重写函数, 函数前还需要主动加上 override
