kotlin之反射

ゝ一世哀愁。 2022-10-27 05:13 249阅读 0赞

# 反射 #

要想使用反射，首先需要添加依赖，下面是maven中的依赖：

<dependencies>
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-reflect</artifactId>
        </dependency>
    </dependencies>

## 根据类获得Class引用 ##

class A
    
    fun main() { 
        var kClass = A::class
        println(kClass) // kclass
        println(kClass.java) // class of java language
    
        var stringClass = String::class
        println(stringClass) // class kotlin.String
        println(stringClass.java) // class java.lang.String
    }

## 根据对象获得Class引用 ##

class B
    
    fun main() { 
        var b = B()
        println(b::class)
        println(b::class.java)
    }

## 方法引用 ##

全局方法引用：

fun isOdd(x: Int) = x % 2 != 0
    
    fun main() { 
        val numbers = listOf(1, 2, 3)
        println(numbers.filter{  isOdd(it)})
        println("------------")
        println(numbers.filter(::isOdd))
    }

支持重载，能根据上下文推导出参数的类型：

fun isOdd(x: Int) = x % 2 != 0
    fun isOdd(s: String) = s == "bob" || s == "tom" || s == "tina"
    
    fun main() { 
        val numbers = listOf(1, 2, 3)
        println(numbers.filter{  isOdd(it)})
        println("------------")
        println(numbers.filter(::isOdd))
        val strings = listOf("morris", "bob", "jack")
        println(strings.filter(::isOdd))
    }

成员方法引用：

fun main() { 
        val strings = listOf("morris", "bob", "jack")
        println(strings.map(String::length))
    }

## 函数组合 ##

fun main() { 
    
        fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C { 
            return {  it -> f(g(it)) }
        }
    
        fun isOdd(a: Int) = a % 2 == 0
    
        val strings = listOf("morris", "bob", "jack")
    
        println(strings.map(compose(::isOdd, String::length)))
    }

## 属性引用 ##

对于可变属性，属性引用返回的是KMutableProperty类型，可以对属性进行set和get。

对于只读属性，属性引用返回的是KProperty类型，只能对属性进行get。

var username = "morris"
    const val age = 10
    
    fun main() { 
        var kMutableProperty0 = ::username
        println(kMutableProperty0.name) // obtain the name of property
        kMutableProperty0.set("kotlin")
        println(kMutableProperty0.get()) // obtain the value of property by get()
    
        var kProperty0 = ::age
        println(kProperty0.name)
        println(kProperty0.get())
    }

要想访问类的成员属性，需要使用全限定名称：

class C(var p: Int)
    
    fun main() { 
        var c = C(0)
        var kMutableProperty1 = C::p
        kMutableProperty1.set(c, 1024) // C.(Int)->Unit <==> (C,Int)->Unit
        println(kMutableProperty1.get(c)) // C.()->Int <==> (C)->Int
    }

扩展函数的反射：

val String.firstChar: Char
        get() = this[0]
    
    fun main() { 
        println(String::firstChar.get("xyz"))
    }

## java反射与kotlin反射的互操作 ##

class D(var p: Int)
    
    fun main() { 
        println(D::p.javaField)
        println(D::p.javaClass)
    
        println(String.javaClass)
        println(String.javaClass.kotlin)
    }

## 构造方法引用 ##

class E(var p: Int)
    
    fun factory(f: (Int) -> E) { 
        var e = f(3)
        println(e.p)
    }
    
    fun main() { 
        factory(::E)
    }

## 对象的方法和属性引用 ##

fun main() { 
        println(String::length.get("xyz"))
        println("xyz"::length.get())
    
        val get = "abc"::get
        println(get(1))
    }

## 反射 ##

### 获取类的基本信息 ###

class F<K, V> : Serializable
    
    fun main() { 
        var kClass = F::class
        println(kClass.superclasses)
        println(kClass.typeParameters)
        println(kClass.qualifiedName)
        println(kClass.simpleName)
    }

### 反射调用构造方法 ###

class G(var name: String = "bob", var age: Int = 18)
    
    fun main() { 
        var kClass = G::class
    
        // 调用无参构造方法
        var gg = kClass.createInstance()
        println(gg.name)
        println(gg.age)
    
        // 调用带参数的构造方法
        var g = kClass.constructors.find {  it.parameters.size == 2 }?.call("morris", 19)
        println(g?.name)
        println(g?.age)
    }

### 反射调用成员方法 ###

class H { 
        fun printSomething(name: String) { 
            println("something: $name")
        }
    
        fun printNothing() { 
            println("nothing")
        }
    }
    
    fun main() { 
        var kClass = H::class
        var h = H()
    
        kClass.functions.find {  it.name == "printNothing" }?.call(h)
    
        var kFunction = kClass.functions.find {  it.name == "printSomething" }
        kFunction?.call(h, "morris")
    
    }