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 <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

//调用高阶函数 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 <T, R> T.let(block: (T) -> R): R {

    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 <T> isType(value: Any) = value is T

Kotlin 提供了一种泛型具体化的技术，它的原理是这样的：

我们知道泛型在运行时会擦除，但是在 inline 函数中我们可以指定泛型不被擦除，

因为 inline 函数在编译期会 copy 到调用它的方法里，所以编译器会知道当前的方法中泛型对应的具体类型是什么，

然后把泛型替换为具体类型，从而达到不被擦除的目的，在 inline 函数中我们可以通过 reified 关键字来标记这个泛型在编译时替换成具体类型

如下面的代码就不会报错了：

inline fun <reified T> isType(value: Any) = value is T

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>(Person("chiclaim", 18), Person("yuzhiqiang", 15),

        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