学习kotlin第十天_对象、委托、委托属性

柔情只为你懂 2022-06-14 00:36 201阅读 0赞

继续跟着官方文档踩坑。

坑1、类似于java中的匿名内部类，kotlin用对象表达式和对象声明来解决对类轻微改动却不显示创建子类。

**fun** main(args: Array<String>) \{   
**val** text=JTextArea()  
    text.addMouseListener(**object** : MouseAdapter() \{   
        **override fun** mouseClicked(e: MouseEvent?) \{   
            **super**.mouseClicked(e)  
        \}  
        **override fun** mouseEntered(e: MouseEvent?) \{   
            **super**.mouseEntered(e)  
        \}  
    \})  
\}

坑2、类似于继承，含有参数的构造函数需要传入相应的参数，实现多个接口时用逗号隔开。

**open class** A(x: Int) \{   
    **open val y**: Int = x  
\}  
**interface** B \{\}  
**val** *ab*: A = **object** : A(1), B \{   
    **override val y** = 15  
\}

坑3、匿名对象不一定有超类，有可能仅有一个对象。

**fun** main(args: Array<String>) \{   
    **val** adHoc = **object** \{   
        **var x**: Int = 1  
        **var y**: Int = 2  
        **fun** a()\{   
            *println*(**"a"**)  
        \}  
    \}  
    adHoc.a()  
    *println*(adHoc.**x** \+ adHoc.**y**)  
\}

坑4、匿名对象可以用作只在本地和私有作用域中声明的类型。如果匿名对象作为公有函数的返回类型或者公有属性的类型，那么实际类型为匿名函数的超类型，没有则为Any。将无法访问匿名对象中添加的成员。

**class** C \{   
    *// 私有函数，所以其返回类型是匿名对象类型  
    ***private fun** foo() = **object** \{   
        **val x**: String = **"x"  
    **\}  
    *// 公有函数，所以其返回类型是 Any  
    ***fun** publicFoo() = **object** \{   
        **val x**: String = **"x"  
    **\}  
    **fun** bar() \{   
        **val** x1 = foo().**x** *// 没问题  
        ***val** x2 = publicFoo().x *// 错误：未能解析的引用“x”  
    *\}  
\}

坑5、对象表达式中的仍然可以访问外部变量。与java不同的是，java中需要是final类型的。

**fun** countClicks(window: JComponent) \{   
    **val** clickCount = 0  
    **var** enterCount = 0  
    window.addMouseListener(**object** : MouseAdapter() \{   
        **override fun** mouseClicked(e: MouseEvent) \{   
            **val** s = clickCount + 1  
        \}  
        **override fun** mouseEntered(e: MouseEvent) \{   
            enterCount++  
        \}  
    \})  
\}

坑6、对象声明在前面已经提到过了，对象声明使用object关键字，类似于变量声明，它不是一个表达式，不能在赋值语句的右边。对象声明不能在函数中，但可以嵌套在其它对象声明或者非内部类中（嵌套类也是非内部类）。

**class** A \{   
     **class** B \{   
        **object** DeclarationTest \{   
            **fun** a(aaa: Int) \{   
                *println*(**"I'm a ,and aaa="** \+ aaa)  
            \}  
            **val b**: Int  
                **get**() = 3  
        \}  
    \}  
\}  
**fun** main(args: Array<String>) \{   
    A.B.DeclarationTest.a(2)  
    *println*(A.B.DeclarationTest.**b**)  
\}

坑7、类内部的伴生对象用companion标记，可通过类名作为限定符来调用。伴生对象名称可以省略，省略后默认为Companion

**class** MyClass \{   
    **companion object** Factory \{   
        *//Factory可以省略，相当于改为Companion  
        ***fun** create(): MyClass = MyClass()  
    \}  
\}  
  
**fun** main(args: Array<String>) \{   
    **val** instance = MyClass.create()  
    *//val c = MyClass.Companion*  
\}

坑8、伴生对象可以实现接口。@JvmStatic注解可以将伴生对象的成员生成为静态方法或字段。

**interface** Factory<T> \{   
    **fun** create(): T  
\}  
**class** MyClass \{   
    **companion object** : Factory<MyClass> \{   
        **override fun** create(): MyClass = MyClass()  
    \}  
\}

坑9、对象表达式、对象声明和半生对象的初始化时间。

l 对象表达式是在使用他们的地方立即执行（及初始化）的

l 对象声明是在第一次被访问到时延迟初始化的

l 伴生对象的初始化是在相应的类被加载（解析）时，与Java  静态初始化器的语义相匹配

坑10、可以使用by关键字将其所有共有的方法委托给一个指定的对象。。。还是不知道有什么用。。。

**interface** Base \{   
    **fun** print()  
\}  
**class** BaseImpl(**val x**: Int) : Base \{   
    **override fun** print() \{   
        *print*(**x**)  
    \}  
\}  
**class** Derived(base: Base) : Base **by** base  
**fun** main(args: Array<String>) \{   
    **val** b = BaseImpl(10)  
    Derived(b).print() *// 输出 10*  
\}

坑11、委托属性用于把一些常见的属性只实现一次并放入一个库。格式为“var/val <属性名>:<类型> by <表达式>”。

class Delegate {
        operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
            return "$thisRef, thank you for delegating '${
       property.name}' to me!"
        }
    
        operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
            println("$value has been assigned to '${
       property.name} in $thisRef.'")
        }
    }
    
    class Example {
        var p: String by Delegate()
    }
    
    fun main(args: Array<String>) {
        val e = Example()
        println(e.p)
        e.p = "sss"
    }

（嘿嘿，换个主题换个心情。）p委托给了Delegate，当实例p被读取时，将调用Delegate中的getValue()函数，第一个参数为读出p的对象，即Example的实例。第二个参数读取出它的对p的描述，如名字。类似地，给p赋值时将调用setValue()函数。此外，value必须和属性同类型或是它的超类型。两函数都必须用operator标记

坑12、lazy()函数接受一个lambda表达式并返回一个Lazy<T>实例，该实例可作为实现延迟属性的委托。get()会执行lambda表达式并记录结果，后续的get方法将只返回结果。

val lazyValue: String by lazy {
        println("computed!")
        return@lazy "Hello"
    }
    fun main(args: Array<String>) {
        println(lazyValue)
        println(lazyValue)
    }

坑13、可观察属性由Delegates.observable()方法实现，接受两个参数，初始值和handler，handler有三个参数，被赋值的属性、旧值和新值。

class User {
        var name: String by Delegates.observable("<no name>") {
            property, oldValue, newValue ->
            println("$property***$oldValue -> $newValue")
        }
    }
    
    fun main(args: Array<String>) {
        val user = User()
        user.name = "first"
        user.name = "second"
    }

坑14、可以使用映射（map）实例自身作为委托来实现委托属性。如果把只读的Map换成MutableMap的话也适用于var属性。

class User(val map: Map<String, Any?>) {
        val name: String  by map
        val age: Int  by map
    }
    
    fun main(args: Array<String>) {
        val user = User(mapOf(
                "name" to "John Doe",
                "age" to 25
        ))
        println(user.name) // Prints "John Doe"
        println(user.age) // Prints 25
    }

坑15、可以将局部变量声明为委托属性。该变量只会在首次访问时计算。

再后面的几个小节又看不懂了，感觉天天都要被虐一顿，官方文档虐我，我来虐你们，估计你们看着我的这几篇水货文章想骂人吧。我也没办法，我也在网上找不到相关参考的资料啊