kotlin笔记

小鱼儿 2021-11-11 09:58 337阅读 0赞

**1、field 关键字**

这个问题对 Java 开发者来说十分难以理解，网上有很多人讨论这个问题，但大多数都是互相抄，说不出个所以然来，要说还是老外对这个问题的理解比较透彻，可以参考这个帖子：[https://stackoverflow.com/questions/43220140/whats-kotlin-backing-field-for/43220314][https_stackoverflow.com_questions_43220140_whats-kotlin-backing-field-for_43220314]

其中最关键的一句：**Remember in kotlin whenever you write foo.bar = value it will be translated into a setter call instead of a PUTFIELD.**

也就是说，在 Kotlin 中，任何时候当你写出“一个变量后边加等于号”这种形式的时候，比如我们定义 var no: Int变量，当你写出 no = ... 这种形式的时候，这个等于号都会被编译器翻译成调用 **setter** 方法；而同样，在任何位置引用变量时，只要出现 **no** 变量的地方都会被编译器翻译成 **getter** 方法。那么问题就来了，当你在 **setter** 方法内部写出 no = ... 时，相当于在 **setter** 方法中调用 **setter** 方法，形成递归，进而形成死循环，例如文中的例子：

var no: Int = 100
        get() = field                // 后端变量
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

这段代码按以上这种写法是正确的，因为使用了 **field** 关键字，但是如果不用 **field** 关键字会怎么样呢？例如：

var no: Int = 100
        get() = no
        set(value) {
            if (value < 10) {       // 如果传入的值小于 10 返回该值
                no = value
            } else {
                no = -1         // 如果传入的值大于等于 10 返回 -1
            }
        }

注意这里我们使用的 Java 的思维写了 **getter** 和 **setter** 方法，那么这时，如果将这段代码翻译成 Java 代码会是怎么样呢？如下：

int no = 100;
    public int getNo() {
        return getNo();// Kotlin中的get() = no语句中出来了变量no，直接被编译器理解成“调用getter方法”
    }
    
    public void setNo(int value) {
        if (value < 10) {
            setNo(value);// Kotlin中出现“no =”这样的字样，直接被编译器理解成“这里要调用setter方法”
        } else {
            setNo(-1);// 在setter方法中调用setter方法，这是不正确的
        }
    }

翻译成 Java 代码之后就很直观了，在 **getter** 方法和 **setter** 方法中都形成了递归调用，显然是不正确的，最终程序会出现内存溢出而异常终止。

**2、嵌套类和内部类在使用时的区别**

（1）创建对象的区别

var demo = Outter.Nested()// 嵌套类，Outter后边没有括号
    var demo = Outter().Inner();// 内部类，Outter后边有括号

也就是说，要想构造内部类的对象，必须先构造外部类的对象，而嵌套类则不需要；

（2）引用外部类的成员变量的方式不同

先来看嵌套类：

class Outer {                  // 外部类
        private val bar: Int = 1
        class Nested {             // 嵌套类
            var ot: Outer = Outer()
            println(ot.bar) // 嵌套类可以引用外部类私有变量，但要先创建外部类的实例，不能直接引用
            fun foo() = 2
        }
    }

再来看一下内部类（引用文章中代码）：

class Outer {
        private val bar: Int = 1
        var v = "成员属性"
        /**嵌套内部类**/
        inner class Inner {
            fun foo() = bar  // 访问外部类成员
            fun innerTest() {
                var o = this@Outer //获取外部类的成员变量
                println("内部类可以引用外部类的成员，例如：" + o.v)
            }
        }
    }

可以看来内部类可以直接通过 this@ 外部类名 的形式引用外部类的成员变量，不需要创建外部类对象；

3、匿名内部类的实现

引用文章中的代码

fun main(args: Array<String>) {
        var test = Test()
    
        /**
         * 采用对象表达式来创建接口对象，即匿名内部类的实例。
         */
        test.setInterFace(object : TestInterFace {
            override fun test() {
                println("对象表达式创建匿名内部类的实例")
            }
        })
    }

特别注意这里的 object : TestInterFace，这个 object 是 Kotlin 的关键字，要实现匿名内部类，就必须使用 object 关键字，不能随意替换其它单词，切记切记。

[https_stackoverflow.com_questions_43220140_whats-kotlin-backing-field-for_43220314]: https://stackoverflow.com/questions/43220140/whats-kotlin-backing-field-for/43220314