1、Kotlin 中没有基础数据类型，都是用它的包装类型，他的包装类型是一个类，我们可以使用类里面很多有用的方法。
2、kotlin访问修饰符
访问修饰符可以修饰类，也可以修饰类的成员。
（1）类访问修饰符
（2）类成员访问修饰符
有几点需要讲一下：
1、 internal 修饰符是 Kotlin 独有而 Java 中没有的；
2、protected 修饰符在Kotlin和Java中的异同点
· protected 修饰类，在 Java 中该类只能被同包名下的类访问，Kotlin 中就算是同包名的类也不能访问 protected 修饰的类。
· protected 修饰类成员，在 Java 中可以被同包名或子类可访问；在 Kotlin 中只能被子类访问。
访问修饰符小结：
（1）如果不写访问修饰符，在 Java 中是 default 修饰符 (package-private)；在 Kotlin 中是 public 的
（2）internal 访问修饰符是 Kotlin 独有，只能在模块内能访问的到
（3）protected 修饰类的时候，不管是 Java 和 Kotlin 都只能放到内部类上
（4）在 Kotlin 中，要继承 protected 类，要么子类在同一内部类名下；要么该类的的外部类和 protected 类的外部类有继承关系
（5）在 Kotlin 中，继承 protected 类，子类也必须是 protected 的
（6）在 Kotlin 中，对于 protected 修饰符，去掉了同包名能访问的特性
（7）如果某个 Kotlin 类能够被继承，需要 open 关键字，默认是 final 的
3、新建 bean 类的时候，常常需要声明 equals、hashCode、toString 等方法，我们需要写很多代码。在 Kotlin 中，只需要在声明类的时候前面加 data 关键字就可以完成这些功能。
4、kotlin 新建内部类,例如：
class OuterClass {
//在 Kotlin 中内部类默认是静态的，不持有外部类的引用
class InnerStaticClass{
}
//如果要声明非静态的内部类，需要加上 inner 关键字
inner class InnerClass{
}
}
编译后代码如下:
class OuterClass {
public static final class InnerStaticClass {
}
public final class InnerClass {
}
}
5、companion object
companion object 称之为伴生对象，伴生体里面放的是一些静态成员：如静态常量、静态变量、静态方法。例如
companion object {
//公有常量
const val FEMALE: Int = 0
const val MALE: Int = 1
//私有常量
val GENDER: Int = FEMALE
//私有静态变量
var username: String = "chiclaim"
//静态方法
fun run() {
println("run...")
}
}
6、Kotlin 中的 Interface
在 Java8 之前，Interface 中是不能包含有方法体的方法和属性，只能包含抽象方法和常量。
在 Kotlin 中的接口在定义的时候可以包含有方法体的方法，也可以包含属性。例如
//声明一个接口，包含方法体的方法 plus 和一个属性 count
interface InterfaceTest {
var count: Int
fun plus(num: Int) {
count += num
}
}
//实现该接口
class Impl : InterfaceTest {
//必须要覆盖 count 属性
override var count: Int = 0
}
7、lambda 表达式
在 Java8 之前，lambda 表达式在 Java 中都是没有的。
（1）lambda 总是放在一个花括号里 ({})
（2）箭头左边是 lambda 参数 (lambda parameter)
（3）箭头右边是 lambda 体 (lambda body)
8、高阶函数
如果某个函数是以另一个函数作为参数或者返回值是一个函数，我们把这样的函数称之为高阶函数。
例如：
//Kotlin library filter function
public inline fun
//调用高阶函数 filter，直接传递 lambda 表达式
list.filter { person ->
person.age > 18
}
function type：
名称 : (参数) -> 返回值类型
（1）冒号左边是 function type 的名字
（2）冒号右边是参数
（3）尖括号右边是返回值
比如：predicate: (T) -> Boolean predicate 就是名字，T 泛型就是参数，Boolean 就是返回值类型
高阶函数是以另一个函数作为参数或者其返回值是一个函数，也可以说高阶函数参数是 function type 或者返回值是 function type
在调用高阶函数的时候，我们可以传递 lambda，这是因为编译器会把 lambda 推导成 function type
9、高阶函数 let、with、apply、run（ 内联函数 ） 总结
（1）let 函数一般用于判断是否为空
//let 函数的定义
public inline fun
return block(this)
}
//let 的使用
message?.let { //lambda参数it是message
val result = it.substring(1)
println(result)
}
（2） with 是全局函数，apply 是扩展函数，其他的都一样
（3）run 函数的 lambda 是一个带有接受者的 lambda，而 let 不是，除此之外功能差不多
10、Kotlin泛型
Java 泛型：不变性 (invariance)、协变性 (covariance)、逆变性 (contravariance)
Kotlin泛型：协变、逆变
Kotlin 泛型擦除和具体化
Kotlin 和 Java 的泛型只在编译时有效，运行时会被擦除 (type erasure)。例如下面的代码就会报错：
//Error: Cannot check for instance of erased type: T
//fun
Kotlin 提供了一种泛型具体化的技术，它的原理是这样的：
我们知道泛型在运行时会擦除，但是在 inline 函数中我们可以指定泛型不被擦除，
因为 inline 函数在编译期会 copy 到调用它的方法里，所以编译器会知道当前的方法中泛型对应的具体类型是什么，
然后把泛型替换为具体类型，从而达到不被擦除的目的，在 inline 函数中我们可以通过 reified 关键字来标记这个泛型在编译时替换成具体类型
如下面的代码就不会报错了：
inline fun
11、Kotlin 集合
Kotlin 中的集合底层也是使用 Java 集合框架那一套。在上层又封装了一层 可变集合 和 不可变集合 接口。
（1）声明可变集合
（2）声明不可变集合
Kotlin 集合常用的 API
1) all、any、count、find、firstOrNull、groupBy 函数
2) filter、map、flatMap、flatten 函数
延迟集合操作之 Sequences(Sequence就是就是为了避免创建多余的集合的问题。)
val list = listOf
Person("johnny", 27), Person("jackson", 190),
Person("pony", 85))
//把 filter 函数放置前面，可以有效减少 map 函数的调用次数
list.asSequence().filter { person ->
println("filter---> ${person.name} : ${person.age}")
person.age > 20
}.map { person ->
println("map----> ${person.name} : ${person.age}")
person.age
}.forEach {
println("---------符合条件的年龄 $it")
}
Sequence 的原理图如下所示：
对 Sequence 做一个小结：
(1)如果集合的数据量很大啊，可以使用集合操作的延迟 Sequence
(2)Sequence 的 filter、map 等扩展还是是一个非 inline 的高阶函数
(3)集合的 Sequence 只有调用 forEach、toList 等操作，才会触发对集合的操作。有点类似 RxJava。
12、Koltin 和 Java 交互的一些问题
1) Kotlin 和 Java 交互上关于空的问题
2) 关于 Kotlin 基本类型初始化问题
3) Kotlin 泛型具体化无法被 Java 调用
如果我们定义了一个 inline 函数，且使用了泛型具体化，该方法不能被 Java 调用。反编译后发现该方法是私有的。只能Kotlin 代码自己调用。
4) Kotlin 间接访问 Java default class