1.修饰符

1.类修饰符

• abstract 抽象类
• final 不可被继承
• enum 枚举类
• open 可继承
• annotation 注解类
• sealed 密封类
• data 数据类

2.成员修饰符

• override 重写函数
• open 可被重写
• final 不可被重写
• abstract 抽象函数
• lateinit 后期初始化

3.访问权限控制

• private
• protected
• public 默认
• internal 整个模块内可访问

4.泛型可变性

• in
• out

2.this关键字

• this关键字持有当前对象的引用。可以使用this来引用变量或者成员函数，也可以使用return this来返回某个类的引用
• 在类的成员中，this指向的是该类的当前对象
• 在扩展函数或者带接收者的函数字面值中，this表示在点左侧传递的接收者参数，例如：

val sum = fun Int.(x:Int):Int = this + x
println(1.sum(1)) //2

• 如果this没有限定符，指的是最内层的包含它的作用域。如果想要引用其他作用域中的this，可以使用this@label标签：

class Outer {
    val oh = "OH!"

    inner class Inner {
        fun m() {
            val outer = this@Outer
            val inner = this@Inner
            println("outer=" + outer)
            println("inner=" + inner)
            println("this=" + this)
            println(outer.oh)

            val fun1 = hello@ fun String.() {
                val obj1 = this //fun1的接收者
                println("obj1=" + obj1)
            }

            val fun2 = { _: String ->
                val obj2 = this
                println("obj2=" + obj2)
            }

            "abc".fun1()
            fun2("def")
        }
    }
}

fun main(args: Array<String>) {
    val outer = Outer()
    outer.Inner().m()
}

//输出：
//outer=com.lpcoder.agile.base.Outer@3764951d
//inner=com.lpcoder.agile.base.Outer$Inner@4b1210ee
//this=com.lpcoder.agile.base.Outer$Inner@4b1210ee
//OH!
//obj1=abc
//obj2=com.lpcoder.agile.base.Outer$Inner@4b1210ee

• super关键字持有指向其父类的引用

3.操作符和操作符重载

1.操作符优先级

2.operator和infix修饰符

• 重载操作符的函数需要用operator修饰符标记。中缀操作符的函数使用infix修饰符标记

3.一元操作符

1.前缀操作符

• 编译器处理+a时的步骤

1. 确定a的类型，令其为T
2. 为接收者T查找一个带有operator修饰符的无参函数unaryPlus()，即成员函数或扩展函数
3. 如果函数不存在或不明确，则导致编译错误
4. 如果函数存在且其返回类型为R，则表达式+a具有类型R

• 重载一元减运算符示例：

data class Point(val x: Int, val y: Int)

operator fun Point.unaryMinus() = Point(-x, -y)

fun main(args: Array<String>) {
    println(-Point(1, 1)) //Point(x=-1, y=-1)
}

2.递增和递减

4.二元操作符

1.算数运算符

2.字符串的+运算符重载

"" + 1 // 1
1 + "" // error
1.toString() + "" // 1

3.自定义重载的+运算符

data class Counter(var index: Int)

operator fun Counter.plus(increment: Int): Counter {
    return Counter(index + increment)
}

fun main(args: Array<String>) {
    println(Counter(5) + 10) //Counter(index=15)
}

4.in操作符

5.索引访问操作符

6.调用操作符

7.计算并赋值

8.相等与不等操作符

• kotlin中有两种类型的相等性

1. 引用相等（两个引用指向同一个对象）：===、 !==
2. 结构相等（使用equals()判断）：==、!=

• 当与null显式比较时，a==null会被自动转换为a===null
• ===和!==不可重载

9.Elvis操作符 ?:

• Elvis操作符是特定用来跟null比较，用来做null安全检查的
• y=x?:0 等价于 y= if (x !== null) x else 0

10.比较操作符

• 所有的比较都转换为对compareTo的调用，这个函数需要返回Int值

11.用infix函数自定义中缀操作符

• 示例：

data class Person(val name: String, val age: Int)

infix fun Person.grow(years: Int): Person {
    return Person(name, age + years)
}

fun main(args: Array<String>) {
    println(Person("Jack", 20).grow(2)) //Person(name=Jack, age=22)
    println(Person("Jack", 20) grow 2) //Person(name=Jack, age=22)
}

4.扩展函数和扩展属性

• 示例：

// 扩展函数
fun String.notEmpty(): Boolean {
    return !this.isEmpty()
}

// 扩展属性
val <T> List<T>.lastIndex: Int get() = size - 1

fun main(args: Array<String>) {
    println("".notEmpty()) //false

    val list = listOf(1,2,3)
    println(list.lastIndex) //2

}

1.扩展函数

• 声明一个扩展函数需要用被扩展的类型做为前缀
• 扩展不是真正的修改所扩展的类，仅仅是通过该类型的变量，用点(.)表达式去调用这个新函数
• 示例：为MutableList<T>添加一个swap函数

fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
    val tmp = this[index1]
    this[index1] = this[index2]
    this[index2] = tmp
}

fun main(args: Array<String>) {
    val list = mutableListOf("a", "b", "c", "d", "e")
    list.swap(0, 4)
    println(list) //[e, b, c, d, a]
}

2.扩展属性

• 由于扩展没有实际地将成员插入类中，因此对于扩展的属性来说，它的行为只能由显式提供的getters/setters定义
• 示例：

val <T> List<T>.lastIndex: Int get() = size -1

5.空指针安全

• kotlin中会发生NPE的情况：

1. 显式调用throw NullPointerException()
2. 使用了!!操作符
3. 调用的外部Java代码有NPE
4. 对于初始化，有一些数据不一致（如一个未初始化的this用于构造函数的某个地方）

• kotlin中一个非空引用不能直接赋值为null

var a = "abc"
a = null //ERROR

• 如果要允许为null，我们可以在变量的类型后面加个问号?，声明一个变量为可空的：

var a:String? = "abc"
a = null 

• 如果我们声明了一个可空String?类型变量a，然后直接调用length属性，这将是不安全的。编译器会直接报错。正确的做法是使用安全调用(?.)和非空断言调用(!!.)

var a:String? = "abc"
a = null 
a?.length //null
a!!.length //NPE

• 安全调用在链式调用中很有用。在调用链中如果任意一个属性(环节)为空，这个链式调用就会安全返回null
• 如果只对非空值执行某个操作，安全调用操作符可以与let（以调用者的值作为参数来执行指定的函数块，并返回其结果）一起使用：

fun main(args: Array<String>) {
    val listWithNulls: List<String?> = listOf("A", "B", null)
    println(listWithNulls)
    listWithNulls.forEach { it?.let { println(it) } }
    //[A, B, null]
    //A
    //B
}

END

参考资料：《Kotlin极简教程》