基础
- ==和equal()相同，===比较内存地址
- 顶级成员（函数&属性）的原理：
Kotlin顶级成员的本质就是Java静态成员，编译后悔自动生成文件名Kt的类，也可以使用@Jvm:fileName注解修改自动生成的类名。 - 默认参数的原理：
Kotlin默认参数的本质是将默认值固化到调用位置，所以在Java中无法直接调用带默认参数的函数，
需要在Kotlin函数上增加@JvmOverloads注解，指示编译器生成重载方法。 - 解构声明的原理：
Kotlin解构声明可以把一个对象的属性结构为一组变量，所以解构声明的本质就是局部变量。
val (name,price)=Book("Kotlin入门",66.6f)
println(name)
println(price)
------------------------------------------
Kotlin类需要声明`operator fun componentN()`方法来实现解构功能。
否则是不具备解构声明的功能的，例如：
class Book(var name:String,var price:Float){
operator fun component1():String{//解构第一个变量
return name
}
operator fun component2():Float{//解构第二个变量
return price
}
}
- 扩展函数的原理：
扩展函数的语义是在不修改类/不继承类的情况下，向一个类添加新函数或新属性。本质是静态函数，
静态函数的第一个参数是接收者类型，调用扩展时不会创建适配对象或者任何运行时的额外消耗。
在Java中，我们只需要像调用普通静态方法那样调用扩展即可。 - 委托机制的原理：
Kotlin委托的语法关键字是by，其本质上是面向编译器的语法糖，三种委托（类委托，对象委托，局部变量委托）在编译时都会
转化为“无糖语法”。
例如类委托：编译器会实现基础接口的所有方法，并直接委托给基础对象来处理。
例如对象委托和局部变量委托：在编译时会生成辅助属性(prop$degelate)，
而属性/变量的getter()和setter()方法只是简单的委托给辅助属性的getValue()和setValue()处理。 - 中缀函数：
声明infix关键字的函数是 中缀函数，可以使用中缀表示法调用（忽略点和括号）
中缀函数的要求：
- 1. 成员函数活扩展函数
- 2. 函数只有一个参数
- 3. 不能使用可变参数或默认参数
举例：
infix fun String.吃(fruit:String):String{
return "${this}吃${fruit}"
}
调用：“小名”吃 "苹果"
类型系统
- 数值类型：
Kotlin将基本数据类型和引用型统一为：Byte、Short、Int、Long、Float、Double、Char和Boolean。
需要注意的是，类型的统一并不意味着Kotlin所有的数值类型都是引用类型，大多数情况下，它们在编译后会变成基本数据类型，
类型参数会被编译为引用类型。
val b:Byte =1 // OK，字面值是静态检测的
val i:Int =b //错误
val i:Int = b.toInt()//ok
- 只读集合 和 可变集合
只读集合只可读，而可变集合可以增删改查（例如List只读，MutableList可变）
需要注意，只读集合引用指向的集合不一定是不可变的，因为你使用的变量可能是众多指向同一个集合的其中一个。 - Array 和 IntArray 的区别：
Array<Int>相当于引用类型数组Integer[]，
IntArray相当于数值类型数组int[]
面向对象
- 类修饰符
Kotlin类/方法默认是final的，如果想让继承类/重写方法，需要在基类/基方法添加open修饰符
final: 不允许继承或重写
open：允许继承或重写
abstract：抽象类/抽象方法
- 访问修饰符
Java默认的访问修饰符是protected，
Kotlin默认的修饰符是public
public：所以地方可见
internal:模块中可见，一个模块就是一组编译的Kotlin文件
protected：子类中可见（与Java不同，相同包不可见）
private：类中可见
-
内部类
Kotlin：默认为静态内部类，如果想访问类中的成员方法和属性，需要添加inner关键字称为非静态内部类；
Java:默认为非静态内部类。 -
Object 与 companion Object 的区别
object有两层语义：静态匿名内部类+单例对象
companion object是伴生对象，一个类只能有一个，代表了类的静态成员（函数/属性） -
object单例的原理
lambda表达式
-
lambda表达式本质上是[可以作为值传递的代码块]，在老版本Java中，传递代码块需要使用匿名内部类实现，而使用lambda表达式甚至连函数声明都不需要，
可以直接传递代码块作为函数值。 -
当lambda表达式只有一个参数，可以用it关键字来引用唯一的实参
-
lambda表达式的种类
1.普通Lambda表达式：例如()->R
2.带接收者对象的lambda表达式：例如T.()->R -
lambda表达式访问局部变量的原理：
在Java中，匿名内部类访问的局部变量必须是final修饰的，否则需要使用数组或对象座一层包装。
在Kotlin中，Lambda表达式可以直接访问非final的局部变量，其原理是提供了一层包装类，修改局部变量本质上是修改包装类中的值。
class Ref<T>(var value:T)
-
内联函数的原理：
lambda表达式编译后会变成匿名内部类，至少会生成一个中间对象，当lambda表达式被经常调用时，会增大运行开销，使用内联函数可以减少中间对象的开销，
因为调用内联函数不会真正调用函数，而是把函数实现固化到函数调用的位置，需要注意：如果函数体太大就不适合使用内联函数了，因为会大幅度增加字节码大小。 -
实化类型参数 reified:
因为泛型擦除的影响，运行期间不清楚类型实参的实际类型，Kotlin中使用带实化类型参数的内联函数，可以突破这种限制，
实化类型参数在插入到调用位置时会使用类型实参的确切类型代替，因此可以确定实参类型。
在这个函数里，我们传入了一个List，企图从中过滤出T类型的元素
Java:
<T>List<T>filter(List list){
List<T> result =new ArrayList<>();
for(Object e:list){
if(e instanceof T){//compiler error
result.add(e);
}
return result;
}
}
---------------------------------
Kotlin:
fun <T> filter(list:List<*>):List<T>{
val result =ArrayList<T>()
for(e in list){
if(e is T){//cannot check for instance of erased type:T
result.add(e)
}
}
return result
}
调用：
val list =listOf("",1,false)
val strList = filter<String>(list)
-----------------------------------------
内联后：
val result =ArrayList<String>()
for(e in list){
if(e is String){
result.add(e)
}
}
协程
- 协程的原理：使用同步代码编写异步程序
本文来自彭旭锐
查看原文
网友评论