Kotlin 跟 Java 可以无缝衔接，因此 Kotlin 能够使用 Java 的反射机制。另外，Kotlin 也有自己的反射机制，需要额外地引入 kotlin-reflect.jar。
implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
kotlin-reflect.jar 中包含 kotlin.reflect.full 和 kotlin.reflect.jvm。
- kotlin.reflect.full 是主要的 Kotlin 反射 API
- kotlin.reflect.jvm 用于 Kotlin 反射和 Java 反射的互操作。
Kotlin 反射的特性包含：
- 提供对属性和可空类型的访问权限，这是由于 Java 没有属性和可空类型的概念。
- Kotlin 反射不是 Java 反射的替代品，而是功能的增强。
- 可以使用 Kotlin 反射来访各种基于 JVM 语言编写的代码。
下面以 Java 的反射和 Kotlin 的反射进行对比。
一. 类引用，获取 Class 对象
Java 获取 Class 对象的方式
- Class.forName("完整的包名+类名")
Class<?> clazz = Class.forName("xxx.xxx.MyClass")
- 类名.class
Class<?> clazz = MyClass.class;
- 实例对象.getClass()
MyClass obj = new MyClass(); Class<?> clazz = obj.getClass();
Kotlin 获取 Class 对象的方式
- 调用的类是 Java 类，需要添加 .java 后缀( KClass 的扩展属性 java)
val clazz = MyClass::class.java
- 添加 Java 实例对象的.javaClass后缀（Java 实例对象的扩展属性 javaClass）。
val obj = MyClass() val clazz = obj.javaClass
- 调用的类是 Kotlin 类
val clazz = MyClass::class
此时 clazz 的类型是 KClass 类型，KClass 的一个实例表示对 Kotlin 类的引用。KClass
也是 Kotlin 反射 API 的主要入口。
在 Kotlin 中，字节码对应的类也是 kotlin.reflect.KClass。
Kotlin 的引用类有两种方式：类名::class和对象::class，它们获取的都是相同的 KClass 实例。
即处于同一个类加载器中，给定的类型只能返回一个 KClass 实例。即使多次尝试实例化 KClass， 仍然只能获取同一对象的引用， Kotlin 不会创建新的引用。
二. 构造函数引用，获取类的构造函数
Java 获取类的构造函数
Java 在获取 Class 实例之后，可以获取其中的构造函数。Java 获取类的构造函数对应的是 java.lang.reflect.Constructor，有以下五种方式：
// 获取参数列表是 parameterTypes，访问 public 的构造函数 public Constructor getConstructor(Class[] parameterTypes) // 获取所有 public 构造函数 public Constructor[] getConstructors() // 获取参数列表是 parameterTypes，并且是类自身声明的构造函数，访问控制符包含 public、protected 和 private 的函数。 public Constructor getDeclaredConstructor(Class[] parameterTypes) // 获取类自身声明的全部的构造函数，包含 public、protected和private 的函数。 public Constructor[] getDeclaredConstructors() // 如果类声明在其它类的构造函数中，返回该类所在的构造函数，如果存在则返回，不存在返回null public Constructor getEnclosingConstructor()
Kotlin 获取类的构造函数
Kotlin 在获取 KClass 实例之后，可以获取它的全部构造函数。
// 类中声明的所有构造函数。 public val constructors: Collection<KFunction<T>>
Kotlin 通过::操作符并添加类名来引用构造函数。例如：
class Foo() fun function(action: () -> Foo) { val foo: Foo = action.invoke() println(foo) // Foo@66d3c617 } fun main() { function(::Foo) }
对于含有参数的构造函数，也一样适用：
class Foo(val x:String) fun main() { val foo = ::Foo // 表示引用 Foo 类的构造函数 val f = foo("test") println(f) }
三. 函数引用，获取类的成员函数
Java 获取类的成员函数
Java 获取类的成员函数对应的是 java.lang.reflect.Method，有以下五种方式：
// 根据函数名 name，参数 parameterTypes 获取类自身的 public 的函数(包括从基类继承的、从接口实现的所有 public 函数) public Method getMethod(String name, Class[] parameterTypes) // 获取全部 public 的函数(包括从基类继承的、从接口实现的所有 public 函数) public Method[] getMethods() // 根据函数名 name，参数 parameterTypes，获取类自身声明的函数，包含 public、protected 和 private 方法。 public Method getDeclaredMethod(String name, Class[] parameterTypes) // 获取类自身声明的函数，包含 public、protected 和 private 方法。 public Method[] getDeclaredMethods() // 如果此 Class 对象表示某一方法中的一个本地或匿名类，则返回 Method 对象，它表示底层类的立即封闭方法。若不存在，返回 null。 public Method getEnclosingMethod()
Kotlin 获取类的成员函数
Kotlin 通过反射调用函数，需要 KFunction 实例。KFunction 实例可以通过两种方式获得：一种是方法引用，另一种是通过 KClass 提供的 API 获得 KFunction 实例。
方法引用是简化版本的 Lambda 表达式，它和 Lambda 表达式拥有相同的特性。
Kotlin 和 Java 的方法引用使用::操作符，Kotlin 除了可以引用类中成员函数、扩展函数还可以引用顶层(top-level)函数。
方法引用属于 KFunction 的子类型 KFunctionN，N 代表具体的参数数量，例如 KFunction2<T1, T2, R>。KFunction 与 Lambda 的 Function 类似，都可以通过invoke()方法调用该引用函数。
例如：
val sum = { x: Int, y: Int -> x + y } fun sumFunction(x: Int, y: Int) = x + y fun main() { println(sum(3,5)) val sunFunc:KFunction2<Int,Int,Int> = ::sumFunction println(sunFunc.invoke(3,5)) println(sunFunc.call(3, 5)) }
执行结果：
8 8 8
KFunctionN 类型属于合成的编译器生成类型，我们无法在包 kotlin.reflect 中找到它们的声明。
在上述例子中，最后一行代码：
println(sunFunc.call(3, 5))
其实这里调用 KCallable 接口的call()方法。
public actual interface KCallable<out R> : KAnnotatedElement { ...... /** * Calls this callable with the specified list of arguments and returns the result. * Throws an exception if the number of specified arguments is not equal to the size of [parameters], * or if their types do not match the types of the parameters. */ public fun call(vararg args: Any?): R ...... }
对于 KFunction 对象，也可以使用 KCallable 的call()方法来调用被引用的函数。
call()方法使用指定的参数列表，开发者需要自行匹配所使用的实参类型和数量，如果其类型与参数的类型不匹配，则会引发异常。
而 KFunctionN 的invoke()方法的形参类型和返回值类型是可以确定的，调用它的 invoke() 时编译器会帮我们做检查。
当然，也可以使用 KFunctionN 来引用类的扩展函数。引用扩展函数的用法跟引用成员函数的用法是一致的。
data class User(var name:String,var password:String) fun User.validatePassword():Boolean = this.password.length > 6 val validate:KFunction1<User,Boolean> = User::validatePassword fun main() { val user = User("tony","12345") println(user.validatePassword()) println(validate.invoke(user)) println(validate.call(user)) }
四. 属性引用，获取类的成员变量
Java 获取类的成员变量
Java 获取类的成员变量对应的是 java.lang.reflect.Field，有以下四种方式：
// 获取相应的类自身声明的 public 成员变量(包括从基类继承的、从接口实现的) public Field getField(String name) // 获取类自身声明全部的 public 成员变量(包括从基类继承的、从接口实现的) public Field[] getFields() // 获取相应的类自身声明的成员变量，包含 public、protected 和 private 成员变量。 public Field getDeclaredField(String name) // 获取类自身声明的成员变量，包含 public、protected 和 private 。 public Field[] getDeclaredFields()
Kotlin 获取类的属性
Kotlin 没有成员变量的概念，只有属性的概念。下面展示了引用不同属性的方式。
不可变属性的引用
Kotlin 使用::属性来获取不可变属性的引用，并返回 KProperty<V> 类型的值。它的get()方法会返回属性的值，它的name属性会返回可变属性的名称。
val x = 1 val y = "hello" fun main() { println(::x) println(::x.get()) println(::x.name) println(::y) println(::y.get()) println(::y.name) }
执行结果：
val x: kotlin.Int 1 x val y: kotlin.String hello y
可变属性的引用
Kotlin 使用::属性来获取可变属性的引用，并返回 KMutableProperty<V> 类型的值。它除了上述的get()方法、name属性，还支持set()方法修改属性的值。
var x = 1 var y = "hello" fun main() { println(::x) ::x.set(0) println(::x.get()) println(::x.name) println(::y) ::y.set("world") println(::y.get()) println(::y.name) }
执行结果：
var x: kotlin.Int 0 x var y: kotlin.String world y
扩展属性的引用
Kotlin 使用类名::属性来获取扩展属性的引用，并返回 KProperty1<T, out V> 类型的值。它的get()、getValue()方法会返回扩展属性的值。
class Extension val Extension.x: Int get() = 1 fun main() { println(Extension::x) // Extension.x: kotlin.Int val extension = Extension() println(Extension::x.get(extension)) // 1 println(Extension::x.getValue(extension,Extension::x)) // 1 }
类的成员属性的引用
Kotlin 使用类名::属性来获取成员属性的引用，并返回 KProperty1<T, out V> 类型的值。它的get()、call()方法会返回成员属性的值。
class Bar1(val x: Int) class Bar2(val x: Int,val y:String) fun main() { val bar1 = Bar1(1) val prop = Bar1::x println(prop.call(bar1)) println(prop.getter.call(bar1)) println(prop.get(bar1)) val bar2 = Bar2(2,"test") val propX = Bar2::x val propY = Bar2::y println(propX.call(bar2)) println(propY.call(bar2)) println(propX.get(bar2)) }
执行结果：
1 1 1 2 test 2
另外，这里的call()方法，依然是 KCallable 接口的call()方法。call()方法的调用最终会调用该属性的 getter 属性。
毕竟，KProperty、KFunction 的超类型都是 KCallable
五. 获取类的其它信息
Java 获取类的其它信息
Java 获取类的注解信息，对应的是 java.lang.annotation.Annotation 接口，有以下三种方式：
// 获取类的 annotationClass 类型的注解 (包括从基类继承的、从接口实现的所有 public 成员变量) public Annotation<A> getAnnotation(Class annotationClass) // 获取类的全部注解 (包括从基类继承的、从接口实现的所有 public 成员变量) public Annotation[] getAnnotations() // 获取类自身声明的全部注解 (包含 public、protected 和 private 成员变量) public Annotation[] getDeclaredAnnotations()
Java 获取类的接口和基类的信息，对应的是 java.lang.reflect.Type 接口，有以下两种方式：
// 获取类实现的全部接口 public Type[] getGenericInterfaces() // 获取类的直接超类的 Type public Type getGenericSuperclass()
Java 获取类的其它描述信息，包括：
// 获取类名 public String getSimpleName() // 获取完整类名 public String getName() // 判断类是不是枚举类 public boolean isEnum() // 判断obj是不是类的实例对象 public boolean isInstance(Object obj) // 判断类是不是接口 public boolean isInterface() // 判断类是不是局部类。局部类所属范围：在块、构造器以及方法内，这里的块包括普通块和静态块。 public boolean isLocalClass() // 判断类是不是成员类 public boolean isMemberClass() // 判断类是不是基本类型。 public boolean isPrimitive()
Kotlin 获取类的其它信息
Kotlin 能够获取更多的类的信息，包括：
// 获取类的名字 public val simpleName: String? // 获取类的全包名 public val qualifiedName: String? // 如果这个类声明为 object，则返回其实例，否则返回 null public val objectInstance: T? // 获取类的可见性 @SinceKotlin("1.1") public val visibility: KVisibility? // 判断类是否为 final 类，Kotlin 默认类是 final 类型的，除非这个类声明为 open 或者 abstract @SinceKotlin("1.1") public val isFinal: Boolean // 判断类是否是open，(abstract 类也是 open），表示这个类可以被继承 @SinceKotlin("1.1") public val isOpen: Boolean // 判断类是否为抽象类 @SinceKotlin("1.1") public val isAbstract: Boolean // 判断类是否为密封类 @SinceKotlin("1.1") public val isSealed: Boolean // 判断类是否为 data class @SinceKotlin("1.1") public val isData: Boolean // 判断类是否为成员类 @SinceKotlin("1.1") public val isInner: Boolean // 判断类是否为 companion object @SinceKotlin("1.1") public val isCompanion: Boolean // 判断类是否为 functional interface @SinceKotlin("1.4") public val isFun: Boolean // 获取类中定义的其他类，包括内部类和嵌套类 public val nestedClasses: Collection<KClass<*>> // 判断一个对象是否为此类的实例 @SinceKotlin("1.1") public fun isInstance(value: Any?): Boolean // 获取这个类的泛型列表 @SinceKotlin("1.1") public val typeParameters: List<KTypeParameter> // 获取类其直接基类的列表 @SinceKotlin("1.1") public val supertypes: List<KType> // 如果该类是密封类，返回子类的列表，否则返回空列表。 @SinceKotlin("1.3") public val sealedSubclasses: List<KClass<out T>> // 获取类所有的基类 val KClass<*>.allSuperclasses: Collection<KClass<*>> // 获取类的伴生对象 companionObject val KClass<*>.companionObject: KClass<*>?
六. Java 反射与 Kotlin 反射的互操作性
为一个 Kotlin 属性获取一个 Java 的 getter/setter 方法或者幕后字段，需要使用 kotlin.reflect.jvm 包。
幕后字段 (backing field) 是 Kotlin 属性自动生成的字段，它只能在当前属性的访问器(getter、setter)内部使用。
- KProperty 的扩展属性 javaGetter：返回给定属性的 getter 相对应的 Java 方法实例，如果该属性没有 getter，则返回 null。
val KProperty<*>.javaGetter: Method? get() = getter.javaMethod
- KProperty 的扩展属性 javaField：返回给定属性的幕后字段相对应的 Java 字段实例，如果属性没有幕后字段，则返回 null。
val KProperty<*>.javaField: Field? get() = this.asKPropertyImpl()?.javaField
- KMutableProperty 的扩展属性 javaSetter：返回给定可变属性的 setter 相对应的 Java 方法实例，如果该属性没有 setter，则返回 null。
val KMutableProperty<*>.javaSetter: Method? get() = setter.javaMethod
如果要获取对应于 Java 的 Kotlin 类，使用 .kotlin 扩展属性返回 KClass 实例。
public val <T : Any> Class<T>.kotlin: KClass<T> @JvmName("getKotlinClass") get() = Reflection.getOrCreateKotlinClass(this) as KClass<T>
