当前位置: 首页>后端>正文

kotlin-反射

什么是反射

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性。

反射的用途

在运行时判断任意一个对象所属的类;
在运行时构造任意一个类的对象;
在运行时判断任意一个类所具有的成员变量和方法;
在运行时调用任意一个对象的方法;

简单使用

java反射

常用API

1.class
getName(): 获取全类名,带包名
getSimpleName(): 获取类名
Class.forName("类名全路径"):返回类对象
getPackage(): 获取包名,有前缀package 
getClassLoader(): 获取类加载器
getClasses(): 获取该类中的公共内部类
getDeclaredClasses(): 获取该类中包含的所有类跟接口,包括非公共的
getSuper(): 获取继承父类类名
getInterfaces(): 获取接口

2.field
getFields(): 获取公共字段
getDeclaredFields(): 获取类中的所有字段
getAnnotation(注解.class): 获取注解

3.construction
getConstructions(): 获取公共的构造方法
getDeclaredConstructions(): 获取所有的构造方法
getDeclaredConstruction(Class... class): 根据参数的类型获取构造方法

4.method
getMethods(): 获取公共方法
getDecleardMethods(): 获取所有的方法
getDeclaredMethod(String name, Class.... params): 根据方法名称跟参数列表获取方法

5.其它方法
isInterface(): 是否是接口
isAnnotation(): 判断是否是注解
isArray(): 是否是数组
isEnum(): 是否是枚举
isAnnotationPresent(Annotation.class): 判断是否有指定注解

6.反射相关方法
setAccessible(true): 设置暴力反射,无视限定符
Field.get(obj): 获取指定对象的field属性值
Field.set(obj, value): 设置obj对象的field属性为value值
Method.invoke(obj, Params.class):执行指定对象的该方法

使用demo

private void Tests() {
    try {
        //通过Java反射机制得到类的包名和类名
        Test1();
        System.out.println("===============================================");
 
        //验证所有的类都是Class类的实例对象
        Test2();
        System.out.println("===============================================");
 
        //通过Java反射机制,用Class 创建类对象[这也就是反射存在的意义所在],无参构造
        Test3();
        System.out.println("===============================================");
 
        //通过Java反射机制得到一个类的构造函数,并实现构造带参实例对象
        Test4();
        System.out.println("===============================================");
 
        //通过Java反射机制操作成员变量, set 和 get
        Test5();
        System.out.println("===============================================");
 
        //通过Java反射机制得到类的一些属性: 继承的接口,父类,函数信息,成员信息,类型等
        Test6();
        System.out.println("===============================================");
 
        //通过Java反射机制调用类中方法
        Test7();
        System.out.println("===============================================");
 
        //通过Java反射机制获得类加载器
        Test8();
        System.out.println("===============================================");
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 
/**
* Demo1: 通过Java反射机制得到类的包名和类名
*/
public static void Test1() {
    Person person = new Person();
    System.out.println("Test1: 包名: " + person.getClass().getPackage().getName() + "," + "完整类名: " + person.getClass().getName());
}
 
/**
* Demo2: 验证所有的类都是Class类的实例对象
*/
public static void Test2() throws ClassNotFoundException {
    //定义两个类型都未知的Class , 设置初值为null, 看看如何给它们赋值成Person类
    Class<?> class1 = null;
    Class<?> class2 = null;
 
    //写法1, 可能抛出 ClassNotFoundException [多用这个写法]
    class1 = Class.forName("com.tuba.yuanyc.audiomanagerdemo.Person");
    System.out.println("Test2:(写法1) 包名: " + class1.getPackage().getName() + "," + "完整类名: " + class1.getName());
 
    //写法2
    class2 = Person.class;
    System.out.println("Test2:(写法2) 包名: " + class2.getPackage().getName() + "," + "完整类名: " + class2.getName());
}
 
/**
* Demo3: 通过Java反射机制,用Class 创建类对象[这也就是反射存在的意义所在]
*/
public static void Test3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
    Class<?> class1 = null;
    class1 = Class.forName("com.android.reflect.Person");
    //由于这里不能带参数,所以你要实例化的这个类Person,一定要有无参构造函数
    Person person = (Person) class1.newInstance();
    person.setAge(26);
    person.setName("kaiven");
    System.out.println("Test3: " + person.getName() + " : " + person.getAge());
}
 
/**
* Demo4: 通过Java反射机制得到一个类的构造函数,并实现创建带参实例对象
*/
public static void Test4() throws ClassNotFoundException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException {
    Class<?> class1 = null;
    Person person1 = null;
    Person person2 = null;
 
    class1 = Class.forName("com.android.reflect.Person");
    //得到一系列构造函数集合
    Constructor<?>[] constructors = class1.getConstructors();
 
    try {
        person1 = (Person) constructors[0].newInstance();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
    person1.setAge(28);
    person1.setName("zhuk");
 
    person2 = (Person) constructors[1].newInstance(29, "zhuk");
 
    System.out.println("Test4: " + person1.getName() + " : " + person1.getAge() + "  ,   " + person2.getName() + " : " + person2.getAge());
 
}
 
/**
* Demo5: 通过Java反射机制操作成员变量, set 和 get
*/
public static void Test5() throws IllegalArgumentException, IllegalAccessException, SecurityException, NoSuchFieldException, InstantiationException, ClassNotFoundException {
    Class<?> class1 = null;
    class1 = Class.forName("com.android.reflect.Person");
    Object obj = class1.newInstance();
 
    Field nameField = class1.getDeclaredField("name");
    nameField.setAccessible(true);
    nameField.set(obj, "cyy");
 
    System.out.println("Test5: 修改属性之后得到属性变量的值:" + nameField.get(obj));
 
}
 
 
/**
* Demo6: 通过Java反射机制得到类的一些属性: 继承的接口,父类,函数信息,成员信息,类型等
*/
public static void Test6() throws ClassNotFoundException {
    Class<?> class1 = null;
    class1 = Class.forName("com.android.reflect.Person");
 
    //取得父类名称
    Class<?> superClass = class1.getSuperclass();
    System.out.println("Test6:  SuperMan类的父类名: " + superClass.getName());
 
    System.out.println("===============================================");
 
 
    Field[] fields = class1.getDeclaredFields();
    for (int i = 0; i < fields.length; i++) {
        System.out.println("类中的成员: " + fields[i]);
    }
    System.out.println("===============================================");
 
 
    //取得类方法
    Method[] methods = class1.getDeclaredMethods();
    for (int i = 0; i < methods.length; i++) {
        System.out.println("Test6,取得SuperMan类的方法:");
        System.out.println("函数名:" + methods[i].getName());
        System.out.println("函数返回类型:" + methods[i].getReturnType());
        System.out.println("函数访问修饰符:" + Modifier.toString(methods[i].getModifiers()));
        System.out.println("函数代码写法: " + methods[i]);
    }
 
    System.out.println("===============================================");
 
    Class<?> interfaces[] = class1.getInterfaces();
    for (int i = 0; i < interfaces.length; i++) {
        System.out.println("实现的接口类名: " + interfaces[i].getName());
    }
 
}
 
/**
* Demo7: 通过Java反射机制调用类方法
*/
public static void Test7() throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException {
    Class<?> class1 = null;
    class1 = Class.forName("com.android.reflect.SuperPerson");
 
    System.out.println("Test7: \n调用无参方法fly():");
    Method method = class1.getMethod("fly");
    method.invoke(class1.newInstance());
 
    System.out.println("调用有参方法smoke(int m):");
    method = class1.getMethod("smoke", int.class);
    method.invoke(class1.newInstance(), 100);
}
 
/**
* Demo8: 通过Java反射机制得到类加载器信息
* <p/>
* 在java中有三种类类加载器。
* <p/>
* 1)Bootstrap ClassLoader 此加载器采用c++编写,一般开发中很少见。
* <p/>
* 2)Extension ClassLoader 用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类
* <p/>
* 3)AppClassLoader 加载classpath指定的类,是最常用的加载器。同时也是java中默认的加载器。
*
* @throws ClassNotFoundException
*/
public static void Test8() throws ClassNotFoundException {
    Class<?> class1 = null;
    class1 = Class.forName("com.android.reflect.SuperPerson");
    String name = class1.getClassLoader().getClass().getName();
 
    System.out.println("Test8: 类加载器类名: " + name);
}

kotlin反射

Kotlin 的反射需要集成 org.jetbrains.kotlin:kotlin-reflect 仓库,版本保持与 kotlin 一致。

implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

在Kotlin中,字节码对应的类是kotlin.reflect.KClass,因为Kotlin百分之百兼容Java,所以Kotlin中可以使用Java中的反射,但是由于Kotlin中字节码.class对应的是KClass类,所以如果想要使用Java中的反射,需要首先获取Class的实例,在Kotlin中可以通过以下两种方式来获取Class实例。

//1.通过实例.javaClass
var hello = HelloWorld()
hello.javaClass

 //2.通过类Kclass类的.java属性
HelloWorld::class.java

获取了Class实例,就可以调用上面介绍的方法,获取各种在Java中定义的类的信息了。

当然Kotlin中除了可以使用Java中的反射以外,还可以使用Kotlin中声明的一些方法,当然同Java中反射一样,想要使用这些方法,先要获取Kclass对象,在Kotlin中可以通过以下两种方式获取Kclass实例。

 //1.通过类::class的方式获取Kclass实例
val clazz1: KClass<*> = HelloWorld::class
//2.通过实例.javaClass.kotlin获取Kclass实例
var hello = HelloWorld()
val clazz2 = hello.javaClass.kotlin

常用API

构造函数Constructor
//返回这个类的所有构造器
public val constructors: Collection<KFunction<T>>

成员变量和成员函数
 //返回类可访问的所有函数和属性,包括继承自基类的,但是不包括构造器
 override val members: Collection<KCallable<*>>
 //返回类声明的所有函数
 val KClass<*>.declaredFunctions: Collection<KFunction<*>>
 //返回类的扩展函数
 val KClass<*>.declaredMemberExtensionFunctions: Collection<KFunction<*>>
 //返回类的扩展属性
 val <T : Any> KClass<T>.declaredMemberExtensionProperties: Collection<KProperty2<T, *, *>>
 //返回类自身声明的成员函数
 val KClass<*>.declaredMemberFunctions: Collection<KFunction<*>>
 //返回类自身声明的成员变量(属性)
 val <T : Any> KClass<T>.declaredMemberProperties: Collection<KProperty1<T, *>>
 
 类相关信息
//1.返回类的名字
public val simpleName: String?
 //2.返回类的全包名
public val qualifiedName: String?
//3.如果这个类声明为object,则返回其实例,否则返回null
public val objectInstance: T?
//4.返回类的可见性
@SinceKotlin("1.1")
public val visibility: KVisibility?
//5.判断类是否为final类(在Kotlin中,类默认是final的,除非这个类声明为open或者abstract)
@SinceKotlin("1.1")
public val isFinal: Boolean
//6.判断类是否是open的(abstract类也是open的),表示这个类可以被继承
@SinceKotlin("1.1")
public val isOpen: Boolean
//7.判断类是否为抽象类
@SinceKotlin("1.1")
public val isAbstract: Boolean
//8.判断类是否为密封类,密封类:用sealed修饰,其子类只能在其内部定义
@SinceKotlin("1.1")
public val isSealed: Boolean
//9.判断类是否为data类
@SinceKotlin("1.1")
public val isData: Boolean
//10.判断类是否为成员类
@SinceKotlin("1.1")
public val isInner: Boolean
//11.判断类是否为companion object
@SinceKotlin("1.1")
public val isCompanion: Boolean 
//12.返回类中定义的其他类,包括内部类(inner class声明的)和嵌套类(class声明的)
public val nestedClasses: Collection<KClass<*>>
 //13.判断一个对象是否为此类的实例
@SinceKotlin("1.1")
public fun isInstance(value: Any?): Boolean
//14.返回这个类的泛型列表
@SinceKotlin("1.1")
public val typeParameters: List<KTypeParameter>
//15.类其直接基类的列表
@SinceKotlin("1.1")
public val supertypes: List<KType>
//16.返回类所有的基类
val KClass<*>.allSuperclasses: Collection<KClass<*>>
//17.返回类的伴生对象companionObject
val KClass<*>.companionObject: KClass<*>?

使用demo

package com.demo.reflect

import kotlin.reflect.KMutableProperty1
import kotlin.reflect.full.*
import kotlin.reflect.jvm.isAccessible


//定义注解
annotation class Anno

@Deprecated("该类已经不推荐使用")
@Anno
class ReflectA(val name: String) {

    companion object{
        const val TAG = "ReflectA"
        fun show(){

        }
    }

    var age: Int = 0

    constructor() : this("ReflectA_")

    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }

    fun print(str: String) {
        println("ReflectA print str $str")
    }

    fun sayHi(): String {
        println("ReflectA sayHi")
        return "sayHi"
    }

    class InnerClass
}

// 拓展方法
fun ReflectA.exfun() {
    println("exfun")
}

// 拓展属性
val ReflectA.foo: Double
    get() = 3.14


fun main() {
    println("Hello word")

    val clazz = ReflectA::class
    println(clazz)

    println("ReflectA 的全部构造器如下:")
    clazz.constructors.forEach {
        println(it)
    }

    println("ReflectA 的主构造器如下:")
    println(clazz.primaryConstructor)

    println(" ")
    //通过functions属性获取该KClass对象所对应类的全部方法
    val funs = clazz.functions
    println("ReflectA 的全部方法如下:")
    funs.forEach { println(it) }

    println(" ")
    //通过 declaredFunctions 属性获取该KClass对象声明的全部方法
    val funs2 = clazz.declaredFunctions
    println("ReflectA 本身声明的全部方法如下:")
    funs2.forEach { println(it) }

    println(" ")
    //通过 memberExtensionFunctions 属性获取全部扩展方法
    val exetensionFunctions = clazz.memberExtensionFunctions
    println("ReflectA 声明的扩展方法如下:")
    exetensionFunctions.forEach { println(it) }

    println(" ")
    //通过decaredMemberProperties获取全部成员属性
    var memberProperties = clazz.declaredMemberProperties
    println("ReflectA 本身声明的成员属性如下:")
    memberProperties.forEach { println(it) }

    println(" ")
    //通过memberExtensionProperties属性获取该KClass对象的全部扩展属性
    var exProperties = clazz.memberExtensionProperties
    println("ReflectA 本身声明的扩展属性如下:")
    exProperties.forEach { println(it) }

    println(" ")
    //通过annotations属性获取该KClass对象所对应类的全部注解
    val anns = clazz.annotations
    println("ReflectA 的全部注解如下:")
    anns.forEach { println(it) }
    println("该KClass元素上的@Annot注解为:${clazz.findAnnotation<Anno>()}")

    println(" ")
    //通过nestedClasses属性获取所对应的全部嵌套类
    val inners = clazz.nestedClasses
    println("ReflectA 的全部内部类如下:")
    inners.forEach { println(it) }

    println(" ")
    //通过supertypes属性获取该类的所有父类型
    println("KClassTest的父类型为:${clazz.supertypes}")


    println(" ")
    println("---------- companion 对象 ---------") //
    val companion = clazz.companionObject // 返回也是一个 KClass
    if (companion != null){
        println("companion $companion")
        companion.declaredMemberProperties.forEach {
            println("companion declaredMemberProperties:  $it")
        }
        companion.declaredFunctions.forEach {
            println("companion declaredFunctions:  $it")
        }
    }


    println(" ")


    println("---------- 创建对象 ---------")
    println(" ")
    println("createInstance 创建实例")
    // createInstance() 方法调用无参数的构造器创建实例
    val inst2 = clazz.createInstance()
    println(inst2.name)
    println(inst2.age)

    println(" ")
    // primaryConstructor 主构造函数
    val cons1 = clazz.primaryConstructor
    val inst1 = cons1?.call("hello reflect")  // 参入参数
    println(inst1)
    println("inst1 " + inst1?.name)

    println(" ")
    println("第一个构造函数")
    val cons2 = clazz.constructors.first()
    println(cons2)

    println(" ")

    println("-------调用方法------")
    val funs3 = clazz.declaredFunctions
    val inst3 = clazz.createInstance()
    println("ReflectA 本身声明的全部方法如下:")
    funs3.forEach { println(it) }
    for (f in funs3) {
        if (f.name == "sayHi") {
            f.call(inst3)
        }
        if (f.name == "print") {
            f.call(inst3, "反射打印")
        }
    }

    println("\n")
    println("-------访问属性------")
    //通过decaredMemberProperties获取全部成员属性
    val memberProperties2 = clazz.declaredMemberProperties
    val inst4 = clazz.createInstance()
    println("ReflectA 本身声明的成员属性如下:")
    memberProperties2.forEach { println(it) }
    println("inst4 name: ${inst4.name}")
    memberProperties2.forEach {
        if (it.name == "age") {
            it as KMutableProperty1<ReflectA, Int>
            it.isAccessible = true
            it.set(inst4, 20)
            println(it.get(inst4))
        }

    }
}


https://www.xamrdz.com/backend/36m1942747.html

相关文章: