反射

• 什么是反射
  kotlin的反射和java反射差不多，第一个作用是获取程序在运行时刻的内部结构，比如检查一个对象的类型，某个类型有哪些构造函数、方法、属性，函数的类型，已经对应的类型参数等。第二个作用是在运行时对一个Java对象进行操作，这些操作包括动态创建一个类型的对象，获取某个属性的值以及调用方法。
• 作用
  很多有名的java框架都是通过反射来实现的，比如spring框架，以及我们熟悉的retrofit是通过动态代理的机制实现的，而动态代理底层是通过反射实现的。

在 Java 平台上，使用反射功能所需的运行时组件作为单独的 JAR 文件( kotlin- reflect.jar )分发。如果你需要使用反射，请确保该 .jar文件添加到项目的 classpath 中。

• 类引用
  kotlin类的元类型是KClass，而java是Class。

 val c: KClass = MyClass::class

//获取对象的类型
val myClass = MyClass()
val c1 = myClass:class

还可以获取下面的信息：

c.isAbstract
c.isCompanion
c.isFinal
c.isOpen
c.supertypes //List<KType>
c.typeParameters //List<KTypeParameter> 返回类型参数
c.constructors //Collection<KFunction<T>>
c.primaryConstructor //KFunction<T>?
c.memberProperties //Collection<KProperty1<T, *>>
c.declaredFunctions //Collection<KFunction<*>>
...

注意 constructors返回的是KFunction<T>类型的对象。
也可以获取java类型：

val javaC: Class<MyClass> = MyClass::class.java

• 函数引用

fun isOdd(x: Int) = x % 2 != 0
fun isOdd(s: String) = s == "brillig" || s == "slithy" || s == "tove"

val numbers = listOf(1, 2, 3) 
println(numbers.filter(::isOdd)) // 引用到 isOdd(x: Int)

你也可以将函数引用存储在变量里：

val predicate: (String) -> Boolean = ::isOdd

如果对函数类型不清楚的同学可以先了解 lambda表达式和匿名函数

示例：函数组合

//函数组合
//compose(f, g) = f(g(*))
fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C {
    return { x -> f(g(x)) }
}

fun length(s: String) = s.length
val oddLength = compose(::isOdd, ::length)
val strings = listOf("a", "ab", "abc")

println(strings.filter(oddLength)) // 输出 "[a, abc]"

• 属性引用
  要把属性作为 Kotlin中 的一等对象来访问，我们也可以使用 :: 运算符:

var x = 1
fun main(args: Array<String>) { 
    println(::x.get()) // 输出 "1" 
    ::x.set(2)
    println(x) // 输出 "2"
}

表达式 ::x 求值为 KProperty<Int> 类型的属性对象，它允许我们使用 get() 读取它的 值，或者使用 name 属性来获取属性名。
对于可变属性，例如 var y = 1 ， ::y 返回 KMutableProperty<Int> 类型的一个值， 该类型 有一个 set() 方法。
属性引用可以用在不需要参数的函数处:

val strs = listOf("a", "bc", "def") 
println(strs.map(String::length)) // 输出 [1, 2, 3]

当我看到官网文档说上面也可以，我就懵逼了，map函数的参数是一个 (T) -> R 的函数类型，为什么String::length 却可以正确输出呢？最后我发现其实 String::length 返回的是 KProperty1<String, Int> ，然后我看他的源码就恍然大悟：

public interface KProperty1<T, out R> : KProperty<R>, (T) -> R {
  ...  
  public fun get(receiver: T): R
  ...
}

上面的代码相当于：

val get: (String) -> Int = {it.length}
val strs = listOf("a", "bc", "def")
println(strs.map(get))

要访问属于类的成员的属性，我们这样限定它:

class A(val p: Int)

fun main(args: Array<String>) {
  val prop = A::p
    println(prop.get(A(1))) // 输出 "1" 
}

对于扩展属性:

val String.lastChar: Char
    get() = this[length - 1]

fun main(args: Array<String>) {
    println(String::lastChar.get("abc")) // 输出 "c"
}

• 构造函数引用
  构造函数可以像方法和属性那样引用。通过使用 :: 操作符并添加类名来 引用构造函数：

class Foo
fun function(factory: () -> Foo) {
    val x: Foo = factory()
}
fun main(args:Array<String>) {
    function(::Foo)
}

其实上面 ::Foo 返回的是 () -> Foo 函数类型的值。

• 绑定的函数与属性引用
  你可以引用特定对象的实例方法。

val numberRegex = "\\d+".toRegex() 
println(numberRegex.matches("29")) // 输出“true”
val isNumber = numberRegex::matches 
println(isNumber("29")) // 输出“true”

上面的代码val isNumber = numberRegex::matches 会将matches的引用存储在 isNumber变量中，这样的引用会绑定到其接收者上。它可 以直接调用(如上例所示)或者用于任何期待一个函数类型表达式的时候:

val strings = listOf("abc", "124", "a70") 
println(strings.filter(isNumber)) // 输出“[124]”

比较绑定的类型和相应的未绑定类型的引用。 绑定的引用有其接收者“附加”到其上， 因此接收者的类型不再是参数:

val isNumber: (CharSequence) -> Boolean = numberRegex::matches
val matches: (Regex, CharSequence) -> Boolean = Regex::matches

属性引用也可以绑定:

val prop = "abc"::length 
println(prop.get()) // 输出“3”

协程

...

类型安全的构建器

...

注解

...